| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/offline_pages/offline_page_storage_manager.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include "base/bind.h" | |
| 10 #include "base/time/clock.h" | |
| 11 #include "base/time/default_clock.h" | |
| 12 #include "components/offline_pages/client_policy_controller.h" | |
| 13 #include "components/offline_pages/offline_page_client_policy.h" | |
| 14 #include "components/offline_pages/offline_page_item.h" | |
| 15 #include "components/offline_pages/offline_page_model.h" | |
| 16 | |
| 17 using LifetimeType = offline_pages::LifetimePolicy::LifetimeType; | |
| 18 | |
| 19 namespace offline_pages { | |
| 20 | |
| 21 OfflinePageStorageManager::OfflinePageStorageManager( | |
| 22 OfflinePageModel* model, | |
| 23 ClientPolicyController* policy_controller, | |
| 24 ArchiveManager* archive_manager) | |
| 25 : model_(model), | |
| 26 policy_controller_(policy_controller), | |
| 27 archive_manager_(archive_manager), | |
| 28 clock_(new base::DefaultClock()), | |
| 29 weak_ptr_factory_(this) {} | |
| 30 | |
| 31 OfflinePageStorageManager::~OfflinePageStorageManager() {} | |
| 32 | |
| 33 void OfflinePageStorageManager::ClearPagesIfNeeded( | |
| 34 const ClearStorageCallback& callback) { | |
| 35 if (IsInProgress()) | |
| 36 return; | |
| 37 clear_time_ = clock_->Now(); | |
| 38 archive_manager_->GetStorageStats(base::Bind( | |
| 39 &OfflinePageStorageManager::OnGetStorageStatsDoneForClearingPages, | |
| 40 weak_ptr_factory_.GetWeakPtr(), callback)); | |
| 41 } | |
| 42 | |
| 43 void OfflinePageStorageManager::SetClockForTesting( | |
| 44 std::unique_ptr<base::Clock> clock) { | |
| 45 clock_ = std::move(clock); | |
| 46 } | |
| 47 | |
| 48 void OfflinePageStorageManager::OnGetStorageStatsDoneForClearingPages( | |
| 49 const ClearStorageCallback& callback, | |
| 50 const ArchiveManager::StorageStats& stats) { | |
| 51 DCHECK(IsInProgress()); | |
| 52 ClearMode mode = ShouldClearPages(stats); | |
| 53 if (mode == ClearMode::NOT_NEEDED) { | |
| 54 last_clear_time_ = clear_time_; | |
| 55 callback.Run(0, ClearStorageResult::UNNECESSARY); | |
| 56 return; | |
| 57 } | |
| 58 model_->GetAllPages( | |
| 59 base::Bind(&OfflinePageStorageManager::OnGetAllPagesDoneForClearingPages, | |
| 60 weak_ptr_factory_.GetWeakPtr(), callback, stats)); | |
| 61 } | |
| 62 | |
| 63 void OfflinePageStorageManager::OnGetAllPagesDoneForClearingPages( | |
| 64 const ClearStorageCallback& callback, | |
| 65 const ArchiveManager::StorageStats& stats, | |
| 66 const MultipleOfflinePageItemResult& pages) { | |
| 67 std::vector<int64_t> page_ids_to_expire; | |
| 68 std::vector<int64_t> page_ids_to_remove; | |
| 69 GetPageIdsToClear(pages, stats, &page_ids_to_expire, &page_ids_to_remove); | |
| 70 model_->ExpirePages( | |
| 71 page_ids_to_expire, clear_time_, | |
| 72 base::Bind(&OfflinePageStorageManager::OnPagesExpired, | |
| 73 weak_ptr_factory_.GetWeakPtr(), callback, | |
| 74 page_ids_to_expire.size(), page_ids_to_remove)); | |
| 75 } | |
| 76 | |
| 77 void OfflinePageStorageManager::OnPagesExpired( | |
| 78 const ClearStorageCallback& callback, | |
| 79 size_t pages_expired, | |
| 80 const std::vector<int64_t>& page_ids_to_remove, | |
| 81 bool expiration_succeeded) { | |
| 82 // We want to delete the outdated page records regardless the expiration | |
| 83 // succeeded or not. | |
| 84 model_->DeletePagesByOfflineId( | |
| 85 page_ids_to_remove, | |
| 86 base::Bind(&OfflinePageStorageManager::OnOutdatedPagesCleared, | |
| 87 weak_ptr_factory_.GetWeakPtr(), callback, pages_expired, | |
| 88 expiration_succeeded)); | |
| 89 } | |
| 90 | |
| 91 void OfflinePageStorageManager::OnOutdatedPagesCleared( | |
| 92 const ClearStorageCallback& callback, | |
| 93 size_t pages_cleared, | |
| 94 bool expiration_succeeded, | |
| 95 DeletePageResult result) { | |
| 96 ClearStorageResult clear_result = ClearStorageResult::SUCCESS; | |
| 97 if (!expiration_succeeded) { | |
| 98 clear_result = ClearStorageResult::EXPIRE_FAILURE; | |
| 99 if (result != DeletePageResult::SUCCESS) | |
| 100 clear_result = ClearStorageResult::EXPIRE_AND_DELETE_FAILURES; | |
| 101 } else if (result != DeletePageResult::SUCCESS) { | |
| 102 clear_result = ClearStorageResult::DELETE_FAILURE; | |
| 103 } | |
| 104 last_clear_time_ = clear_time_; | |
| 105 callback.Run(pages_cleared, clear_result); | |
| 106 } | |
| 107 | |
| 108 void OfflinePageStorageManager::GetPageIdsToClear( | |
| 109 const MultipleOfflinePageItemResult& pages, | |
| 110 const ArchiveManager::StorageStats& stats, | |
| 111 std::vector<int64_t>* page_ids_to_expire, | |
| 112 std::vector<int64_t>* page_ids_to_remove) { | |
| 113 // TODO(romax): See how persistent should be considered here. | |
| 114 // Creating a map from namespace to a vector of page items. | |
| 115 // Sort each vector based on last accessed time and all pages after index | |
| 116 // min{size(), page_limit} should be expired. And then start iterating | |
| 117 // backwards to expire pages. | |
| 118 std::map<std::string, std::vector<OfflinePageItem>> pages_map; | |
| 119 std::vector<OfflinePageItem> kept_pages; | |
| 120 int64_t kept_pages_size = 0; | |
| 121 | |
| 122 for (const auto& page : pages) { | |
| 123 if (!page.IsExpired()) { | |
| 124 pages_map[page.client_id.name_space].push_back(page); | |
| 125 } else if (clear_time_ - page.expiration_time >= kRemovePageItemInterval) { | |
| 126 page_ids_to_remove->push_back(page.offline_id); | |
| 127 } | |
| 128 } | |
| 129 | |
| 130 for (auto& iter : pages_map) { | |
| 131 std::string name_space = iter.first; | |
| 132 std::vector<OfflinePageItem>& page_list = iter.second; | |
| 133 | |
| 134 LifetimePolicy policy = | |
| 135 policy_controller_->GetPolicy(name_space).lifetime_policy; | |
| 136 | |
| 137 std::sort(page_list.begin(), page_list.end(), | |
| 138 [](const OfflinePageItem& a, const OfflinePageItem& b) -> bool { | |
| 139 return a.last_access_time > b.last_access_time; | |
| 140 }); | |
| 141 | |
| 142 size_t page_list_size = page_list.size(); | |
| 143 size_t pos = 0; | |
| 144 while (pos < page_list_size && | |
| 145 (policy.page_limit == kUnlimitedPages || pos < policy.page_limit) && | |
| 146 !ShouldBeExpired(page_list.at(pos))) { | |
| 147 kept_pages_size += page_list.at(pos).file_size; | |
| 148 kept_pages.push_back(page_list.at(pos)); | |
| 149 pos++; | |
| 150 } | |
| 151 | |
| 152 for (; pos < page_list_size; pos++) | |
| 153 page_ids_to_expire->push_back(page_list.at(pos).offline_id); | |
| 154 } | |
| 155 | |
| 156 // If we're still over the clear threshold, we're going to clear remaining | |
| 157 // pages from oldest last access time. | |
| 158 int64_t free_space = stats.free_disk_space; | |
| 159 int64_t total_size = stats.total_archives_size; | |
| 160 int64_t space_to_release = | |
| 161 kept_pages_size - | |
| 162 (total_size + free_space) * kOfflinePageStorageClearThreshold; | |
| 163 if (space_to_release > 0) { | |
| 164 // Here we're sorting the |kept_pages| with oldest first. | |
| 165 std::sort(kept_pages.begin(), kept_pages.end(), | |
| 166 [](const OfflinePageItem& a, const OfflinePageItem& b) -> bool { | |
| 167 return a.last_access_time < b.last_access_time; | |
| 168 }); | |
| 169 size_t kept_pages_size = kept_pages.size(); | |
| 170 size_t pos = 0; | |
| 171 while (pos < kept_pages_size && space_to_release > 0) { | |
| 172 space_to_release -= kept_pages.at(pos).file_size; | |
| 173 page_ids_to_expire->push_back(kept_pages.at(pos).offline_id); | |
| 174 pos++; | |
| 175 } | |
| 176 } | |
| 177 } | |
| 178 | |
| 179 OfflinePageStorageManager::ClearMode | |
| 180 OfflinePageStorageManager::ShouldClearPages( | |
| 181 const ArchiveManager::StorageStats& storage_stats) { | |
| 182 int64_t total_size = storage_stats.total_archives_size; | |
| 183 int64_t free_space = storage_stats.free_disk_space; | |
| 184 if (total_size == 0) | |
| 185 return ClearMode::NOT_NEEDED; | |
| 186 | |
| 187 // If the size of all offline pages is more than limit, or it's larger than a | |
| 188 // specified percentage of all available storage space on the disk we'll clear | |
| 189 // all offline pages. | |
| 190 if (total_size >= (total_size + free_space) * kOfflinePageStorageLimit) | |
| 191 return ClearMode::DEFAULT; | |
| 192 // If it's been more than the pre-defined interval since the last time we | |
| 193 // clear the storage, we should clear pages. | |
| 194 if (last_clear_time_ == base::Time() || | |
| 195 clear_time_ - last_clear_time_ >= kClearStorageInterval) { | |
| 196 return ClearMode::DEFAULT; | |
| 197 } | |
| 198 // Otherwise there's no need to clear storage right now. | |
| 199 return ClearMode::NOT_NEEDED; | |
| 200 } | |
| 201 | |
| 202 bool OfflinePageStorageManager::ShouldBeExpired( | |
| 203 const OfflinePageItem& page) const { | |
| 204 const LifetimePolicy& policy = | |
| 205 policy_controller_->GetPolicy(page.client_id.name_space).lifetime_policy; | |
| 206 return policy.lifetime_type == LifetimeType::TEMPORARY && | |
| 207 clear_time_ - page.last_access_time >= policy.expiration_period; | |
| 208 } | |
| 209 | |
| 210 bool OfflinePageStorageManager::IsInProgress() const { | |
| 211 return clear_time_ > last_clear_time_; | |
| 212 } | |
| 213 | |
| 214 } // namespace offline_pages | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2489443002:
Move all components/offline_pages/ files into component/offline_pages/core (Closed)
