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

components/offline_pages/offline_page_storage_manager_unittest.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_storage_manager.h"
 
 #include <stdint.h>
 #include <map>
 #include <vector>
 
@@ skipping 12 matching lines @@
 using LifetimePolicy = offline_pages::LifetimePolicy;
 using ClearStorageResult =
     offline_pages::OfflinePageStorageManager::ClearStorageResult;
 using StorageStats = offline_pages::ArchiveManager::StorageStats;
 
 namespace offline_pages {
 
 namespace {
 const GURL kTestUrl("http://example.com");
 const base::FilePath::CharType kFilePath[] = FILE_PATH_LITERAL("/data");
-const int64_t kTestFileSize = 500 * (1 << 10);
+const int64_t kTestFileSize = 1 << 19;  // Make a page 512KB.
 const int64_t kFreeSpaceNormal = 100 * (1 << 20);
 
 enum TestOptions {
   DEFAULT = 1 << 0,
   EXPIRE_FAILURE = 1 << 1,
   DELETE_FAILURE = 1 << 2,
   EXPIRE_AND_DELETE_FAILURES = EXPIRE_FAILURE | DELETE_FAILURE,
 };
 
 struct PageSettings {
@@ skipping 240 matching lines @@
   TryClearPages();
   EXPECT_EQ(45, last_cleared_page_count());
   EXPECT_EQ(1, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   EXPECT_EQ(0, static_cast<int>(model()->GetRemovedPages().size()));
 }
 
 TEST_F(OfflinePageStorageManagerTest, TestClearPagesMoreFreshPages) {
   Initialize(std::vector<PageSettings>(
                  {{kBookmarkNamespace, 30, 0}, {kLastNNamespace, 100, 1}}),
-             {500 * (1 << 20), 0});
+             {1000 * (1 << 20), 0});
   clock()->Advance(base::TimeDelta::FromMinutes(30));
   TryClearPages();
-  int last_n_page_limit = static_cast<int>(policy_controller()
-                                               ->GetPolicy(kLastNNamespace)
-                                               .lifetime_policy.page_limit);
-  EXPECT_EQ(1 + (100 - last_n_page_limit), last_cleared_page_count());
+  EXPECT_EQ(1, last_cleared_page_count());
   EXPECT_EQ(1, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   EXPECT_EQ(0, static_cast<int>(model()->GetRemovedPages().size()));
 }
 
 TEST_F(OfflinePageStorageManagerTest, TestDeletionFailed) {
   Initialize(std::vector<PageSettings>(
                  {{kBookmarkNamespace, 10, 10}, {kLastNNamespace, 10, 10}}),
              {kFreeSpaceNormal, 0}, TestOptions::DELETE_FAILURE);
   TryClearPages();
@@ skipping 63 matching lines @@
   TryClearPages();
   EXPECT_EQ(10, last_cleared_page_count());
   EXPECT_EQ(2, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   EXPECT_EQ(10, static_cast<int>(model()->GetRemovedPages().size()));
 }
 
 TEST_F(OfflinePageStorageManagerTest, TestClearMultipleTimes) {
   Initialize(std::vector<PageSettings>(
                  {{kBookmarkNamespace, 30, 0}, {kLastNNamespace, 100, 1}}),
-             {500 * (1 << 20), 0});
+             {1000 * (1 << 20), 0});
   clock()->Advance(base::TimeDelta::FromMinutes(30));
   LifetimePolicy policy =
       policy_controller()->GetPolicy(kLastNNamespace).lifetime_policy;
-  int last_n_page_limit = static_cast<int>(policy.page_limit);
 
   TryClearPages();
-  EXPECT_EQ(1 + (100 - last_n_page_limit), last_cleared_page_count());
+  EXPECT_EQ(1, last_cleared_page_count());
   EXPECT_EQ(1, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   EXPECT_EQ(0, static_cast<int>(model()->GetRemovedPages().size()));
 
   // Advance the clock by expiration period of last_n namespace, should be
   // expiring all pages left in the namespace.
   clock()->Advance(policy.expiration_period);
   TryClearPages();
-  EXPECT_EQ(last_n_page_limit, last_cleared_page_count());
+  EXPECT_EQ(100, last_cleared_page_count());
   EXPECT_EQ(2, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   EXPECT_EQ(0, static_cast<int>(model()->GetRemovedPages().size()));
 
   // Only 1 ms passes and no changes in pages, so no need to clear page.
   clock()->Advance(base::TimeDelta::FromMilliseconds(1));
   TryClearPages();
   EXPECT_EQ(0, last_cleared_page_count());
   EXPECT_EQ(3, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::UNNECESSARY, last_clear_storage_result());
@@ skipping 21 matching lines @@
   EXPECT_EQ(0, model()->GetTotalSize());
   EXPECT_EQ(5, total_cleared_times());
   EXPECT_EQ(ClearStorageResult::SUCCESS, last_clear_storage_result());
   // Number of removed pages should be the ones expired above and all the pages
   // initially created for last_n namespace.
   EXPECT_EQ(expired_page_count + 101,
             static_cast<int>(model()->GetRemovedPages().size()));
 }
 
 }  // namespace offline_pages