Update access info when an offline page is being visited

components/offline_pages/offline_page_model.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 94 matching lines @@
                                 scoped_ptr<OfflinePageArchiver> archiver,
                                 const SavePageCallback& callback) {
   DCHECK(is_loaded_);
   DCHECK(archiver.get());
   archiver->CreateArchive(base::Bind(&OfflinePageModel::OnCreateArchiveDone,
                                      weak_ptr_factory_.GetWeakPtr(), url,
                                      bookmark_id, callback));
   pending_archivers_.push_back(archiver.Pass());
 }
 
+void OfflinePageModel::MarkPageAccessed(int64 bookmark_id) {
+  DCHECK(is_loaded_);
+  auto iter = offline_pages_.find(bookmark_id);
+  if (iter == offline_pages_.end())
+    return;
+
+  iter->second.last_access_time = base::Time::Now();
+  iter->second.access_count++;
+  store_->AddOrUpdateOfflinePage(
+      iter->second,
+      base::Bind(&OfflinePageModel::OnUpdateOfflinePageDone,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
 void OfflinePageModel::DeletePageByBookmarkId(
     int64 bookmark_id,
     const DeletePageCallback& callback) {
   DCHECK(is_loaded_);
   std::vector<int64> bookmark_ids_to_delete;
   bookmark_ids_to_delete.push_back(bookmark_id);
   DeletePagesByBookmarkId(bookmark_ids_to_delete, callback);
 }
 
 void OfflinePageModel::DeletePagesByBookmarkId(
@@ skipping 84 matching lines @@
 
   if (archiver_result != ArchiverResult::SUCCESSFULLY_CREATED) {
     SavePageResult result = ToSavePageResult(archiver_result);
     InformSavePageDone(callback, result);
     DeletePendingArchiver(archiver);
     return;
   }
 
   OfflinePageItem offline_page_item(url, bookmark_id, file_path, file_size,
                                     base::Time::Now());
-  store_->AddOfflinePage(
+  store_->AddOrUpdateOfflinePage(
       offline_page_item,
       base::Bind(&OfflinePageModel::OnAddOfflinePageDone,
                  weak_ptr_factory_.GetWeakPtr(), archiver, callback,
                  offline_page_item));
 }
 
 void OfflinePageModel::OnAddOfflinePageDone(OfflinePageArchiver* archiver,
                                             const SavePageCallback& callback,
                                             const OfflinePageItem& offline_page,
                                             bool success) {
   SavePageResult result;
   if (success) {
     offline_pages_[offline_page.bookmark_id] = offline_page;
     result = SavePageResult::SUCCESS;
     UMA_HISTOGRAM_MEMORY_KB(
         "OfflinePages.PageSize", offline_page.file_size / 1024);
   } else {
     result = SavePageResult::STORE_FAILURE;
   }
   InformSavePageDone(callback, result);
   DeletePendingArchiver(archiver);
 }
 
+void OfflinePageModel::OnUpdateOfflinePageDone(bool success) {
+}
+
 void OfflinePageModel::BookmarkModelChanged() {
 }
 
 void OfflinePageModel::BookmarkNodeRemoved(
     bookmarks::BookmarkModel* model,
     const bookmarks::BookmarkNode* parent,
     int old_index,
     const bookmarks::BookmarkNode* node,
     const std::set<GURL>& removed_urls) {
   if (!is_loaded_) {
@@ skipping 85 matching lines @@
 void OfflinePageModel::InformDeletePageDone(const DeletePageCallback& callback,
                                             DeletePageResult result) {
   UMA_HISTOGRAM_ENUMERATION(
       "OfflinePages.DeletePageResult",
       static_cast<int>(result),
       static_cast<int>(DeletePageResult::RESULT_COUNT));
   callback.Run(result);
 }
 
 }  // namespace offline_pages