Update access info when an offline page is being visited

components/offline_pages/offline_page_metadata_store_impl.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_metadata_store_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 25 matching lines @@
   std::string path_string;
 #if defined(OS_POSIX)
   path_string = item.file_path.value();
 #elif defined(OS_WIN)
   path_string = base::WideToUTF8(item.file_path.value());
 #endif
   item_proto->set_file_path(path_string);
   item_proto->set_file_size(item.file_size);
   item_proto->set_creation_time(item.creation_time.ToInternalValue());
   item_proto->set_last_access_time(item.last_access_time.ToInternalValue());
+  item_proto->set_access_count(item.access_count);
 }
 
 bool OfflinePageItemFromEntry(const offline_pages::OfflinePageEntry& item_proto,
                               OfflinePageItem* item) {
   DCHECK(item);
   if (!item_proto.has_url() || !item_proto.has_bookmark_id() ||
       !item_proto.has_version() || !item_proto.has_file_path()) {
     return false;
   }
   item->url = GURL(item_proto.url());
   item->bookmark_id = item_proto.bookmark_id();
   item->version = item_proto.version();
 #if defined(OS_POSIX)
   item->file_path = base::FilePath(item_proto.file_path());
 #elif defined(OS_WIN)
   item->file_path = base::FilePath(base::UTF8ToWide(item_proto.file_path()));
 #endif
   if (item_proto.has_file_size()) {
     item->file_size = item_proto.file_size();
   }
   if (item_proto.has_creation_time()) {
     item->creation_time =
         base::Time::FromInternalValue(item_proto.creation_time());
   }
   if (item_proto.has_last_access_time()) {
     item->last_access_time =
         base::Time::FromInternalValue(item_proto.last_access_time());
   }
+  if (item_proto.has_access_count()) {
+    item->access_count = item_proto.access_count();
+  }
   return true;
 }
 
 void OnLoadDone(const OfflinePageMetadataStore::LoadCallback& callback,
                 const base::Callback<void()>& failure_callback,
                 bool success,
                 scoped_ptr<OfflinePageEntryVector> entries) {
   UMA_HISTOGRAM_BOOLEAN("OfflinePages.LoadSuccess", success);
   if (!success) {
     DVLOG(1) << "Offline pages database load failed.";
@@ skipping 64 matching lines @@
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, false, std::vector<OfflinePageItem>()));
     return;
   }
 
   database_->LoadEntries(base::Bind(
       &OnLoadDone, callback, base::Bind(&OfflinePageMetadataStoreImpl::ResetDB,
                                         weak_ptr_factory_.GetWeakPtr())));
 }
 
-void OfflinePageMetadataStoreImpl::AddOfflinePage(
+void OfflinePageMetadataStoreImpl::AddOrUpdateOfflinePage(
     const OfflinePageItem& offline_page_item,
     const UpdateCallback& callback) {
   scoped_ptr<ProtoDatabase<OfflinePageEntry>::KeyEntryVector> entries_to_save(
       new ProtoDatabase<OfflinePageEntry>::KeyEntryVector());
   scoped_ptr<std::vector<std::string>> keys_to_remove(
       new std::vector<std::string>());
 
   OfflinePageEntry offline_page_proto;
   OfflinePageItemToEntry(offline_page_item, &offline_page_proto);
   entries_to_save->push_back(
@@ skipping 38 matching lines @@
                  base::Bind(&OfflinePageMetadataStoreImpl::ResetDB,
                             weak_ptr_factory_.GetWeakPtr())));
 }
 
 void OfflinePageMetadataStoreImpl::ResetDB() {
   database_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace offline_pages