Support serving offline page by offline ID

components/offline_pages/offline_page_model_impl.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_model_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #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/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "components/offline_pages/archive_manager.h"
 #include "components/offline_pages/client_namespace_constants.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 "url/gurl.h"
 
 using ArchiverResult = offline_pages::OfflinePageArchiver::ArchiverResult;
 using ClearStorageCallback =
@@ skipping 113 matching lines @@
   // Note: The factory creates and owns the histogram.
   base::HistogramBase* histogram = base::LinearHistogram::FactoryGet(
       AddHistogramSuffix(client_id, "OfflinePages.SavePageResult"),
       1,
       static_cast<int>(SavePageResult::RESULT_COUNT),
       static_cast<int>(SavePageResult::RESULT_COUNT) + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(static_cast<int>(result));
 }
 
-void ReportPageHistogramAfterSave(const OfflinePageItem& offline_page) {
+void ReportPageHistogramAfterSave(const OfflinePageItem& offline_page,
+                                  base::Clock* clock) {
   // The histogram below is an expansion of the UMA_HISTOGRAM_TIMES
   // macro adapted to allow for a dynamically suffixed histogram name.
   // Note: The factory creates and owns the histogram.
   base::HistogramBase* histogram = base::Histogram::FactoryTimeGet(
       AddHistogramSuffix(offline_page.client_id, "OfflinePages.SavePageTime"),
       base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromSeconds(10),
       50, base::HistogramBase::kUmaTargetedHistogramFlag);
-  histogram->AddTime(base::Time::Now() - offline_page.creation_time);
+  histogram->AddTime(clock->Now() - offline_page.creation_time);
 
   // The histogram below is an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
   // macro adapted to allow for a dynamically suffixed histogram name.
   // Note: The factory creates and owns the histogram.
   // Reported as Kb between 1Kb and 10Mb.
   histogram = base::Histogram::FactoryGet(
       AddHistogramSuffix(offline_page.client_id, "OfflinePages.PageSize"),
       1, 10000, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(offline_page.file_size / 1024);
 }
 
 void ReportPageHistogramsAfterDelete(
     const std::map<int64_t, OfflinePageItem>& offline_pages,
-    const std::vector<int64_t>& deleted_offline_ids) {
+    const std::vector<int64_t>& deleted_offline_ids,
+    base::Clock* clock) {
   const int max_minutes = base::TimeDelta::FromDays(365).InMinutes();
-  base::Time now = base::Time::Now();
+  base::Time now = clock->Now();
   int64_t total_size = 0;
   for (int64_t offline_id : deleted_offline_ids) {
     auto iter = offline_pages.find(offline_id);
     if (iter == offline_pages.end())
       continue;
     total_size += iter->second.file_size;
     ClientId client_id = iter->second.client_id;
 
     // The histograms below are an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
     // macro adapted to allow for a dynamically suffixed histogram name.
@@ skipping 30 matching lines @@
   }
 
   if (deleted_offline_ids.size() > 1) {
     UMA_HISTOGRAM_COUNTS("OfflinePages.BatchDelete.Count",
                          static_cast<int32_t>(deleted_offline_ids.size()));
     UMA_HISTOGRAM_MEMORY_KB(
         "OfflinePages.BatchDelete.TotalPageSize", total_size / 1024);
   }
 }
 
-void ReportPageHistogramsAfterAccess(const OfflinePageItem& offline_page_item) {
+void ReportPageHistogramsAfterAccess(const OfflinePageItem& offline_page_item,
+                                     base::Clock* clock) {
   // The histogram below is an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
   // macro adapted to allow for a dynamically suffixed histogram name.
   // Note: The factory creates and owns the histogram.
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
         AddHistogramSuffix(
             offline_page_item.client_id,
             offline_page_item.access_count == 0 ?
                 "OfflinePages.FirstOpenSinceCreated" :
                 "OfflinePages.OpenSinceLastOpen"),
         1, kMaxOpenedPageHistogramBucket.InMinutes(), 50,
         base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(
-      (base::Time::Now() - offline_page_item.last_access_time).InMinutes());
+      (clock->Now() - offline_page_item.last_access_time).InMinutes());
 }
 
 }  // namespace
 
 // protected
 OfflinePageModelImpl::OfflinePageModelImpl()
     : OfflinePageModel(), is_loaded_(false), weak_ptr_factory_(this) {}
 
 OfflinePageModelImpl::OfflinePageModelImpl(
     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),
       policy_controller_(new ClientPolicyController()),
       archive_manager_(new ArchiveManager(archives_dir, task_runner)),
+      clock_(new base::DefaultClock()),
       weak_ptr_factory_(this) {
   archive_manager_->EnsureArchivesDirCreated(
       base::Bind(&OfflinePageModelImpl::OnEnsureArchivesDirCreatedDone,
                  weak_ptr_factory_.GetWeakPtr(), base::TimeTicks::Now()));
 }
 
 OfflinePageModelImpl::~OfflinePageModelImpl() {}
 
 void OfflinePageModelImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
@@ skipping 27 matching lines @@
   }
 
   // If we already have an offline id, use it.  If not, generate one.
   if (proposed_offline_id == 0l)
     proposed_offline_id = GenerateOfflineId();
 
   archiver->CreateArchive(
       archives_dir_, proposed_offline_id,
       base::Bind(&OfflinePageModelImpl::OnCreateArchiveDone,
                  weak_ptr_factory_.GetWeakPtr(), url, proposed_offline_id,
-                 client_id, base::Time::Now(), callback));
+                 client_id, clock_->Now(), callback));
   pending_archivers_.push_back(std::move(archiver));
 }
 
 void OfflinePageModelImpl::MarkPageAccessed(int64_t offline_id) {
   RunWhenLoaded(base::Bind(&OfflinePageModelImpl::MarkPageAccessedWhenLoadDone,
                            weak_ptr_factory_.GetWeakPtr(), offline_id));
 }
 
 void OfflinePageModelImpl::MarkPageAccessedWhenLoadDone(int64_t offline_id) {
   DCHECK(is_loaded_);
 
   auto iter = offline_pages_.find(offline_id);
   if (iter == offline_pages_.end() || iter->second.IsExpired())
     return;
 
   // Make a copy of the cached item and update it. The cached item should only
   // be updated upon the successful store operation.
   OfflinePageItem offline_page_item = iter->second;
 
-  ReportPageHistogramsAfterAccess(offline_page_item);
+  ReportPageHistogramsAfterAccess(offline_page_item, clock_.get());
 
-  offline_page_item.last_access_time = base::Time::Now();
+  offline_page_item.last_access_time = clock_->Now();
   offline_page_item.access_count++;
 
   store_->AddOrUpdateOfflinePage(
       offline_page_item,
       base::Bind(&OfflinePageModelImpl::OnMarkPageAccesseDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_page_item));
 }
 
 void OfflinePageModelImpl::DeletePagesByOfflineId(
     const std::vector<int64_t>& offline_ids,
@@ skipping 333 matching lines @@
 }
 
 ClientPolicyController* OfflinePageModelImpl::GetPolicyController() {
   return policy_controller_.get();
 }
 
 OfflinePageMetadataStore* OfflinePageModelImpl::GetStoreForTesting() {
   return store_.get();
 }
 
+void OfflinePageModelImpl::SetClockForTesting(
+    std::unique_ptr<base::Clock> clock) {
+  clock_ = std::move(clock);
+}
+
 OfflinePageStorageManager* OfflinePageModelImpl::GetStorageManager() {
   return storage_manager_.get();
 }
 
 bool OfflinePageModelImpl::is_loaded() const {
   return is_loaded_;
 }
 
 OfflineEventLogger* OfflinePageModelImpl::GetLogger() {
   return &offline_event_logger_;
@@ skipping 37 matching lines @@
 
 void OfflinePageModelImpl::OnAddOfflinePageDone(
     OfflinePageArchiver* archiver,
     const SavePageCallback& callback,
     const OfflinePageItem& offline_page,
     bool success) {
   SavePageResult result;
   if (success) {
     offline_pages_[offline_page.offline_id] = offline_page;
     result = SavePageResult::SUCCESS;
-    ReportPageHistogramAfterSave(offline_page);
+    ReportPageHistogramAfterSave(offline_page, clock_.get());
     offline_event_logger_.RecordPageSaved(
         offline_page.client_id.name_space, offline_page.url.spec(),
         std::to_string(offline_page.offline_id));
   } else {
     result = SavePageResult::STORE_FAILURE;
   }
   InformSavePageDone(callback, result, offline_page.client_id,
                      offline_page.offline_id);
   if (result == SavePageResult::SUCCESS) {
     DeleteExistingPagesWithSameURL(offline_page);
@@ skipping 138 matching lines @@
   store_->RemoveOfflinePages(
       offline_ids,
       base::Bind(&OfflinePageModelImpl::OnRemoveOfflinePagesDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_ids, callback));
 }
 
 void OfflinePageModelImpl::OnRemoveOfflinePagesDone(
     const std::vector<int64_t>& offline_ids,
     const DeletePageCallback& callback,
     bool success) {
-  ReportPageHistogramsAfterDelete(offline_pages_, offline_ids);
+  ReportPageHistogramsAfterDelete(offline_pages_, offline_ids, clock_.get());
 
   for (int64_t offline_id : offline_ids) {
     offline_event_logger_.RecordPageDeleted(std::to_string(offline_id));
     auto iter = offline_pages_.find(offline_id);
     if (iter == offline_pages_.end())
       continue;
     FOR_EACH_OBSERVER(
         Observer, observers_,
         OfflinePageDeleted(iter->second.offline_id, iter->second.client_id));
     offline_pages_.erase(iter);
@@ skipping 28 matching lines @@
   std::vector<int64_t> ids_of_pages_missing_archive_file;
   for (const auto& id_page_pair : offline_pages_) {
     if (archive_paths.count(id_page_pair.second.file_path) == 0UL)
       ids_of_pages_missing_archive_file.push_back(id_page_pair.first);
   }
 
   if (ids_of_pages_missing_archive_file.empty())
     return;
 
   ExpirePages(
-      ids_of_pages_missing_archive_file, base::Time::Now(),
+      ids_of_pages_missing_archive_file, clock_->Now(),
       base::Bind(&OfflinePageModelImpl::OnExpirePagesMissingArchiveFileDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  ids_of_pages_missing_archive_file));
 }
 
 void OfflinePageModelImpl::OnExpirePagesMissingArchiveFileDone(
     const std::vector<int64_t>& offline_ids,
     bool success) {
   UMA_HISTOGRAM_COUNTS("OfflinePages.Consistency.PagesMissingArchiveFileCount",
                        static_cast<int32_t>(offline_ids.size()));
@@ skipping 112 matching lines @@
 void OfflinePageModelImpl::RunWhenLoaded(const base::Closure& task) {
   if (!is_loaded_) {
     delayed_tasks_.push_back(task);
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
 }
 
 }  // namespace offline_pages