Expire appcaches that fail to update for "too long".

content/browser/appcache/appcache_storage_impl.cc

 // Copyright (c) 2012 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 "content/browser/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 452 matching lines @@
     // TODO(michaeln): histogram is fishing for clues to crbug/95101
     if (!cache->get()->GetEntry(group_record_.manifest_url)) {
       AppCacheHistograms::AddMissingManifestDetectedAtCallsite(
           AppCacheHistograms::CALLSITE_1);
     }
   } else {
     (*group) = new AppCacheGroup(
         storage_, group_record_.manifest_url,
         group_record_.group_id);
     group->get()->set_creation_time(group_record_.creation_time);
+    group->get()->set_last_full_update_check_time(
+        group_record_.last_full_update_check_time);
+    group->get()->set_first_evictable_error_time(
+        group_record_.first_evictable_error_time);
     group->get()->AddCache(cache->get());
 
     // TODO(michaeln): histogram is fishing for clues to crbug/95101
     if (!cache->get()->GetEntry(group_record_.manifest_url)) {
       AppCacheHistograms::AddMissingManifestDetectedAtCallsite(
           AppCacheHistograms::CALLSITE_2);
     }
   }
   DCHECK(group->get()->newest_complete_cache() == cache->get());
 
@@ skipping 142 matching lines @@
 };
 
 AppCacheStorageImpl::StoreGroupAndCacheTask::StoreGroupAndCacheTask(
     AppCacheStorageImpl* storage, AppCacheGroup* group, AppCache* newest_cache)
     : StoreOrLoadTask(storage), group_(group), cache_(newest_cache),
       success_(false), would_exceed_quota_(false),
       space_available_(-1), new_origin_usage_(-1) {
   group_record_.group_id = group->group_id();
   group_record_.manifest_url = group->manifest_url();
   group_record_.origin = group_record_.manifest_url.GetOrigin();
+  group_record_.last_full_update_check_time =
+      group->last_full_update_check_time();
+  group_record_.first_evictable_error_time =
+      group->first_evictable_error_time();
   newest_cache->ToDatabaseRecords(
       group,
       &cache_record_, &entry_records_,
       &intercept_namespace_records_,
       &fallback_namespace_records_,
       &online_whitelist_records_);
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::GetQuotaThenSchedule() {
   storage::QuotaManager* quota_manager = NULL;
@@ skipping 52 matching lines @@
     group_record_.last_access_time = base::Time::Now();
     success_ = database_->InsertGroup(&group_record_);
   } else {
     DCHECK(group_record_.group_id == existing_group.group_id);
     DCHECK(group_record_.manifest_url == existing_group.manifest_url);
     DCHECK(group_record_.origin == existing_group.origin);
 
     database_->UpdateLastAccessTime(group_record_.group_id,
                                     base::Time::Now());
 
+    database_->UpdateEvictionTimes(
+        group_record_.group_id,
+        group_record_.last_full_update_check_time,
+        group_record_.first_evictable_error_time);
+
     AppCacheDatabase::CacheRecord cache;
     if (database_->FindCacheForGroup(group_record_.group_id, &cache)) {
       // Get the set of response ids in the old cache.
       std::set<int64> existing_response_ids;
       database_->FindResponseIdsForCacheAsSet(cache.cache_id,
                                               &existing_response_ids);
 
       // Remove those that remain in the new cache.
       std::vector<AppCacheDatabase::EntryRecord>::const_iterator entry_iter =
           entry_records_.begin();
@@ skipping 631 matching lines @@
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "AppCacheStorageImpl::CommitLastAccessTimesTask"));
     database_->CommitLazyLastAccessTimes();
   }
 
  protected:
   ~CommitLastAccessTimesTask() override {}
 };
 
+// UpdateEvictionTimes -------
+
+class AppCacheStorageImpl::UpdateEvictionTimesTask
+    : public DatabaseTask {
+ public:
+  UpdateEvictionTimesTask(
+      AppCacheStorageImpl* storage, AppCacheGroup* group)
+      : DatabaseTask(storage), group_id_(group->group_id()),
+        last_full_update_check_time_(group->last_full_update_check_time()),
+        first_evictable_error_time_(group->first_evictable_error_time()) {
+  }
+
+  // DatabaseTask:
+  void Run() override;
+
+ protected:
+  ~UpdateEvictionTimesTask() override {}
+
+ private:
+  int64 group_id_;
+  base::Time last_full_update_check_time_;
+  base::Time first_evictable_error_time_;
+};
+
+void AppCacheStorageImpl::UpdateEvictionTimesTask::Run() {
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "AppCacheStorageImpl::UpdateEvictionTimes"));
+  database_->UpdateEvictionTimes(group_id_,
+                                 last_full_update_check_time_,
+                                 first_evictable_error_time_);
+}
+
 // AppCacheStorageImpl ---------------------------------------------------
 
 AppCacheStorageImpl::AppCacheStorageImpl(AppCacheServiceImpl* service)
     : AppCacheStorage(service),
       is_incognito_(false),
       is_response_deletion_scheduled_(false),
       did_start_deleting_responses_(false),
       last_deletable_response_rowid_(0),
       database_(NULL),
       is_disabled_(false),
@@ skipping 299 matching lines @@
 void AppCacheStorageImpl::MakeGroupObsolete(AppCacheGroup* group,
                                             Delegate* delegate,
                                             int response_code) {
   DCHECK(group && delegate);
   scoped_refptr<MakeGroupObsoleteTask> task(
       new MakeGroupObsoleteTask(this, group, response_code));
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
 }
 
+void AppCacheStorageImpl::StoreEvictionTimes(AppCacheGroup* group) {
+  scoped_refptr<UpdateEvictionTimesTask> task(
+      new UpdateEvictionTimesTask(this, group));
+  task->Schedule();
+}
+
 AppCacheResponseReader* AppCacheStorageImpl::CreateResponseReader(
     const GURL& manifest_url, int64 group_id, int64 response_id) {
   return new AppCacheResponseReader(response_id, group_id, disk_cache());
 }
 
 AppCacheResponseWriter* AppCacheStorageImpl::CreateResponseWriter(
     const GURL& manifest_url, int64 group_id) {
   return new AppCacheResponseWriter(NewResponseId(), group_id, disk_cache());
 }
 
@@ skipping 234 matching lines @@
 
 void AppCacheStorageImpl::OnLazyCommitTimer() {
   lazy_commit_timer_.Stop();
   if (is_disabled())
     return;
   scoped_refptr<DatabaseTask> task(new CommitLastAccessTimesTask(this));
   task->Schedule();
 }
 
 }  // namespace content