Merge M54: 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/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 156 matching lines @@
   if (matching_url_count != nullptr)
     *matching_url_count = count;
   if (most_recent_creation_time != nullptr && latest_time != base::Time())
     *most_recent_creation_time = created_before - latest_time;
 
   return matching_page;
 }
 
 void ReportPageHistogramAfterSave(
     const std::map<int64_t, OfflinePageItem>& offline_pages,
-    const OfflinePageItem& offline_page) {
+    const OfflinePageItem& offline_page,
+    const base::Time& save_time) {
   // 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(save_time - 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);
 
@@ skipping 12 matching lines @@
           base::TimeDelta::FromSeconds(1).InSeconds(),
           base::TimeDelta::FromDays(7).InSeconds(), 50);
     }
     UMA_HISTOGRAM_CUSTOM_COUNTS("OfflinePages.DownloadSavedPageDuplicateCount",
                                 matching_url_count, 1, 20, 10);
   }
 }
 
 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,
+    const base::Time& delete_time) {
   const int max_minutes = base::TimeDelta::FromDays(365).InMinutes();
-  base::Time now = base::Time::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;
 
     if (client_id.name_space == kDownloadNamespace) {
       int remaining_pages_with_url;
       GetMatchingURLCountAndMostRecentCreationTime(
           offline_pages, iter->second.client_id.name_space, iter->second.url,
           base::Time::Max(), &remaining_pages_with_url, nullptr);
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "OfflinePages.DownloadDeletedPageDuplicateCount",
           remaining_pages_with_url, 1, 20, 10);
     }
 
     // The histograms below are 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(client_id, "OfflinePages.PageLifetime"),
         1, max_minutes, 100, base::HistogramBase::kUmaTargetedHistogramFlag);
-    histogram->Add((now - iter->second.creation_time).InMinutes());
+    histogram->Add((delete_time - iter->second.creation_time).InMinutes());
 
     histogram = base::Histogram::FactoryGet(
         AddHistogramSuffix(
             client_id, "OfflinePages.DeletePage.TimeSinceLastOpen"),
         1, max_minutes, 100, base::HistogramBase::kUmaTargetedHistogramFlag);
-    histogram->Add((now - iter->second.last_access_time).InMinutes());
+    histogram->Add((delete_time - iter->second.last_access_time).InMinutes());
 
     histogram = base::Histogram::FactoryGet(
         AddHistogramSuffix(
             client_id, "OfflinePages.DeletePage.LastOpenToCreated"),
         1, max_minutes, 100, base::HistogramBase::kUmaTargetedHistogramFlag);
     histogram->Add(
         (iter->second.last_access_time - iter->second.creation_time).
             InMinutes());
 
     // Reported as Kb between 1Kb and 10Mb.
     histogram = base::Histogram::FactoryGet(
         AddHistogramSuffix(client_id, "OfflinePages.DeletePage.PageSize"),
         1, 10000, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
     histogram->Add(iter->second.file_size / 1024);
 
     histogram = base::Histogram::FactoryGet(
         AddHistogramSuffix(client_id, "OfflinePages.DeletePage.AccessCount"),
         1, 1000000, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
     histogram->Add(iter->second.access_count);
   }
 
   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,
+                                     const base::Time& access_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.
   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());
+      (access_time - 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)),
+      testing_clock_(nullptr),
       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 == 0ul)
     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, GetCurrentTime(), 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, GetCurrentTime());
 
-  offline_page_item.last_access_time = base::Time::Now();
+  offline_page_item.last_access_time = GetCurrentTime();
   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 390 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_pages_, offline_page);
+    ReportPageHistogramAfterSave(offline_pages_, offline_page,
+                                 GetCurrentTime());
     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, GetCurrentTime());
 
   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, GetCurrentTime(),
       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 111 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);
 }
 
+base::Time OfflinePageModelImpl::GetCurrentTime() const {
+  return testing_clock_ ? testing_clock_->Now() : base::Time::Now();
+}
+
 }  // namespace offline_pages