[Offline Pages] Duplicate pages when save/delete bookmarks.

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"
@@ skipping 779 matching lines @@
       kStorageManagerStartingDelay);
 }
 
 void OfflinePageModelImpl::InformSavePageDone(const SavePageCallback& callback,
                                               SavePageResult result,
                                               const ClientId& client_id,
                                               int64_t offline_id) {
   ReportSavePageResultHistogramAfterSave(client_id, result);
   archive_manager_->GetStorageStats(
       base::Bind(&ReportStorageHistogramsAfterSave));
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&OfflinePageModelImpl::ClearStorageIfNeeded,
-                            weak_ptr_factory_.GetWeakPtr(),
-                            base::Bind(&OfflinePageModelImpl::OnStorageCleared,
-                                       weak_ptr_factory_.GetWeakPtr())));
+  // Remove existing pages generated by the same policy and with same url.
+  size_t pages_allowed =
+      policy_controller_->GetPolicy(client_id.name_space).pages_allowed_per_url;
+  if (result == SavePageResult::SUCCESS && pages_allowed != kUnlimitedPages) {
+    GetPagesByOnlineURL(
+        offline_pages_[offline_id].url,
+        base::Bind(&OfflinePageModelImpl::OnPagesFoundWithSameURL,
+                   weak_ptr_factory_.GetWeakPtr(), client_id, offline_id,
+                   pages_allowed));
+  } else {
+    PostClearStorageIfNeededTask();
+  }
   callback.Run(result, offline_id);
 }
 
+void OfflinePageModelImpl::OnPagesFoundWithSameURL(
+    const ClientId& client_id,
+    int64_t offline_id,
+    size_t pages_allowed,
+    const MultipleOfflinePageItemResult& items) {
+  std::vector<OfflinePageItem> pages_to_delete;
+  for (const auto& item : items) {
+    if (item.offline_id != offline_id &&
+        item.client_id.name_space == client_id.name_space) {
+      pages_to_delete.push_back(item);
+    }
+  }
+  // Only keep |pages_allowed|-1 of most fresh pages and delete others, by
+  // sorting pages with the oldest  ones first and resize the vector.
+  if (pages_to_delete.size() >= pages_allowed) {
+    sort(pages_to_delete.begin(), pages_to_delete.end(),
+         [](const OfflinePageItem& a, const OfflinePageItem& b) -> bool {
+           return a.last_access_time < b.last_access_time;
+         });
+    pages_to_delete.resize(pages_to_delete.size() - pages_allowed + 1);
+  }
+  std::vector<int64_t> page_ids_to_delete;
+  for (const auto& item : pages_to_delete)
+    page_ids_to_delete.push_back(item.offline_id);
+  DeletePagesByOfflineId(
+      page_ids_to_delete,
+      base::Bind(&OfflinePageModelImpl::OnDeleteOldPagesWithSameURL,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void OfflinePageModelImpl::OnDeleteOldPagesWithSameURL(
+    DeletePageResult result) {
+  // TODO(romax) Add UMAs for failure cases.
+  PostClearStorageIfNeededTask();
+}
+
 void OfflinePageModelImpl::DeletePendingArchiver(
     OfflinePageArchiver* archiver) {
   pending_archivers_.erase(std::find(pending_archivers_.begin(),
                                      pending_archivers_.end(), archiver));
 }
 
 void OfflinePageModelImpl::OnDeleteArchiveFilesDone(
     const std::vector<int64_t>& offline_ids,
     const DeletePageCallback& callback,
     bool success) {
@@ skipping 155 matching lines @@
                                             ClearStorageResult result) {
   UMA_HISTOGRAM_ENUMERATION("OfflinePages.ClearStorageResult",
                             static_cast<int>(result),
                             static_cast<int>(ClearStorageResult::RESULT_COUNT));
   if (expired_page_count > 0) {
     UMA_HISTOGRAM_COUNTS("OfflinePages.ExpirePage.BatchSize",
                          static_cast<int32_t>(expired_page_count));
   }
 }
 
+void OfflinePageModelImpl::PostClearStorageIfNeededTask() {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&OfflinePageModelImpl::ClearStorageIfNeeded,
+                            weak_ptr_factory_.GetWeakPtr(),
+                            base::Bind(&OfflinePageModelImpl::OnStorageCleared,
+                                       weak_ptr_factory_.GetWeakPtr())));
+}
+
 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