Update access info when an offline page is being visited

components/offline_pages/offline_page_model_unittest.cc

 // Copyright 2015 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.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 30 matching lines @@
     REMOVE_FAILED,
   };
 
   explicit OfflinePageTestStore(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
   explicit OfflinePageTestStore(const OfflinePageTestStore& other_store);
   ~OfflinePageTestStore() override;
 
   // OfflinePageMetadataStore overrides:
   void Load(const LoadCallback& callback) override;
-  void AddOfflinePage(const OfflinePageItem& offline_page,
-                      const UpdateCallback& callback) override;
+  void AddOrUpdateOfflinePage(const OfflinePageItem& offline_page,
+                              const UpdateCallback& callback) override;
   void RemoveOfflinePages(const std::vector<int64>& bookmark_ids,
                           const UpdateCallback& callback) override;
   const OfflinePageItem& last_saved_page() const { return last_saved_page_; }
 
   void set_test_scenario(TestScenario scenario) { scenario_ = scenario; };
 
   const std::vector<OfflinePageItem>& offline_pages() const {
     return offline_pages_;
   }
 
@@ skipping 25 matching lines @@
 void OfflinePageTestStore::Load(const LoadCallback& callback) {
   if (scenario_ != TestScenario::LOAD_FAILED) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(callback, true, offline_pages_));
   } else {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(callback, false, std::vector<OfflinePageItem>()));
   }
 }
 
-void OfflinePageTestStore::AddOfflinePage(const OfflinePageItem& offline_page,
-                                          const UpdateCallback& callback) {
+void OfflinePageTestStore::AddOrUpdateOfflinePage(
+    const OfflinePageItem& offline_page, const UpdateCallback& callback) {
   last_saved_page_ = offline_page;
   bool result = scenario_ != TestScenario::WRITE_FAILED;
   if (result) {
     offline_pages_.push_back(offline_page);
   }
   task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
 }
 
 void OfflinePageTestStore::RemoveOfflinePages(
     const std::vector<int64>& bookmark_ids,
@@ skipping 253 matching lines @@
 
   ResetResults();
 
   const std::vector<OfflinePageItem>& offline_pages = model()->GetAllPages();
 
   EXPECT_EQ(1UL, offline_pages.size());
   EXPECT_EQ(kTestUrl, offline_pages[0].url);
   EXPECT_EQ(kTestPageBookmarkId1, offline_pages[0].bookmark_id);
   EXPECT_EQ(archiver_path, offline_pages[0].file_path);
   EXPECT_EQ(kTestFileSize, offline_pages[0].file_size);
+  EXPECT_EQ(0, offline_pages[0].access_count);
 }
 
 TEST_F(OfflinePageModelTest, SavePageOfflineArchiverCancelled) {
   scoped_ptr<OfflinePageTestArchiver> archiver(
       BuildArchiver(kTestUrl,
                     OfflinePageArchiver::ArchiverResult::ERROR_CANCELED)
           .Pass());
   model()->SavePage(
       kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
@@ skipping 113 matching lines @@
 
   ResetResults();
 
   const std::vector<OfflinePageItem>& offline_pages = model()->GetAllPages();
 
   EXPECT_EQ(2UL, offline_pages.size());
   EXPECT_EQ(kTestUrl, offline_pages[0].url);
   EXPECT_EQ(kTestPageBookmarkId1, offline_pages[0].bookmark_id);
   EXPECT_EQ(archiver_path, offline_pages[0].file_path);
   EXPECT_EQ(kTestFileSize, offline_pages[0].file_size);
+  EXPECT_EQ(0, offline_pages[0].access_count);
   EXPECT_EQ(kTestUrl2, offline_pages[1].url);
   EXPECT_EQ(kTestPageBookmarkId2, offline_pages[1].bookmark_id);
   EXPECT_EQ(archiver_path2, offline_pages[1].file_path);
   EXPECT_EQ(kTestFileSize, offline_pages[1].file_size);
+  EXPECT_EQ(0, offline_pages[1].access_count);
+}
+
+TEST_F(OfflinePageModelTest, MarkPageAccessed) {
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
+  PumpLoop();
+
+  // This will increase access_count by one.
+  model()->MarkPageAccessed(kTestPageBookmarkId1);
+  base::RunLoop().RunUntilIdle();
+
+  const std::vector<OfflinePageItem>& offline_pages = model()->GetAllPages();
+
+  EXPECT_EQ(1UL, offline_pages.size());
+  EXPECT_EQ(kTestUrl, offline_pages[0].url);
+  EXPECT_EQ(kTestPageBookmarkId1, offline_pages[0].bookmark_id);
+  EXPECT_EQ(kTestFileSize, offline_pages[0].file_size);
+  EXPECT_EQ(1, offline_pages[0].access_count);
 }
 
 TEST_F(OfflinePageModelTest, GetAllPagesStoreEmpty) {
   const std::vector<OfflinePageItem>& offline_pages = model()->GetAllPages();
 
   EXPECT_EQ(0UL, offline_pages.size());
 }
 
 TEST_F(OfflinePageModelTest, GetAllPagesStoreFailure) {
   GetStore()->set_test_scenario(
@@ skipping 165 matching lines @@
 }
 
 // Test that model returns pages that are older than 30 days as candidates for
 // clean up, hence the numbers in time delta.
 TEST_F(OfflinePageModelTest, GetPagesToCleanUp) {
   base::Time now = base::Time::Now();
   OfflinePageItem page_1(
       GURL(kTestUrl), kTestPageBookmarkId1,
       base::FilePath(FILE_PATH_LITERAL("/test/location/page1.mhtml")),
       kTestFileSize, now - base::TimeDelta::FromDays(40));
-  GetStore()->AddOfflinePage(
+  GetStore()->AddOrUpdateOfflinePage(
       page_1,
       base::Bind(&OfflinePageModelTest::OnStoreUpdateDone, AsWeakPtr()));
   PumpLoop();
 
   OfflinePageItem page_2(
       GURL(kTestUrl2), kTestPageBookmarkId2,
       base::FilePath(FILE_PATH_LITERAL("/test/location/page2.mhtml")),
       kTestFileSize, now - base::TimeDelta::FromDays(31));
-  GetStore()->AddOfflinePage(
+  GetStore()->AddOrUpdateOfflinePage(
       page_2,
       base::Bind(&OfflinePageModelTest::OnStoreUpdateDone, AsWeakPtr()));
   PumpLoop();
 
   OfflinePageItem page_3(
       GURL("http://test.xyz"), 42,
       base::FilePath(FILE_PATH_LITERAL("/test/location/page3.mhtml")),
       kTestFileSize, now - base::TimeDelta::FromDays(29));
-  GetStore()->AddOfflinePage(
+  GetStore()->AddOrUpdateOfflinePage(
       page_3,
       base::Bind(&OfflinePageModelTest::OnStoreUpdateDone, AsWeakPtr()));
   PumpLoop();
 
   ResetModel();
 
   // Only page_1 and page_2 are expected to be picked up by the model as page_3
   // has not been in the store long enough.
   std::vector<OfflinePageItem> pages_to_clean_up = model()->GetPagesToCleanUp();
   EXPECT_EQ(2UL, pages_to_clean_up.size());
   EXPECT_EQ(kTestUrl, pages_to_clean_up[0].url);
   EXPECT_EQ(kTestPageBookmarkId1, pages_to_clean_up[0].bookmark_id);
   EXPECT_EQ(kTestUrl2, pages_to_clean_up[1].url);
   EXPECT_EQ(kTestPageBookmarkId2, pages_to_clean_up[1].bookmark_id);
 }
 
 }  // namespace offline_pages