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

content/browser/appcache/appcache_update_job_unittest.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 10 matching lines @@
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 class AppCacheUpdateJobTest;
 
 namespace {
 
+// Values should match values used in appcache_update_job.cc.
+const base::TimeDelta kFullUpdateInterval =
+    base::TimeDelta::FromHours(24);
+const base::TimeDelta kMaxEvictableErrorDuration =
+    base::TimeDelta::FromDays(14);
+const base::TimeDelta kOneHour =
+    base::TimeDelta::FromHours(1);
+
 const char kManifest1Contents[] =
     "CACHE MANIFEST\n"
     "explicit1\n"
     "FALLBACK:\n"
     "fallback1 fallback1a\n"
     "NETWORK:\n"
     "*\n";
 
 // There are a handful of http accessible resources that we need to conduct
 // these tests. Instead of running a seperate server to host these resources,
@@ skipping 543 matching lines @@
 };
 
 class AppCacheUpdateJobTest : public testing::Test,
                               public AppCacheGroup::UpdateObserver {
  public:
   AppCacheUpdateJobTest()
       : do_checks_after_update_finished_(false),
         expect_group_obsolete_(false),
         expect_group_has_cache_(false),
         expect_group_is_being_deleted_(false),
+        expect_evictable_error_(false),
+        expect_eviction_(false),
         expect_old_cache_(NULL),
         expect_newest_cache_(NULL),
         expect_non_null_update_time_(false),
         tested_manifest_(NONE),
         tested_manifest_path_override_(NULL) {
     io_thread_.reset(new IOThread("AppCacheUpdateJob IO test thread"));
     base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
     io_thread_->StartWithOptions(options);
   }
 
@@ skipping 22 matching lines @@
 
     MockFrontend mock_frontend;
     AppCacheHost host(1, &mock_frontend, service_.get());
 
     update->StartUpdate(&host, GURL());
 
     // Verify state.
     EXPECT_EQ(AppCacheUpdateJob::CACHE_ATTEMPT, update->update_type_);
     EXPECT_EQ(AppCacheUpdateJob::FETCH_MANIFEST, update->internal_state_);
     EXPECT_EQ(AppCacheGroup::CHECKING, group_->update_status());
+    EXPECT_TRUE(update->doing_full_update_check_);
 
     // Verify notifications.
     MockFrontend::RaisedEvents& events = mock_frontend.raised_events_;
     size_t expected = 1;
     EXPECT_EQ(expected, events.size());
     EXPECT_EQ(expected, events[0].first.size());
     EXPECT_EQ(host.host_id(), events[0].first[0]);
     EXPECT_EQ(APPCACHE_CHECKING_EVENT, events[0].second);
 
     // Abort as we're not testing actual URL fetches in this test.
@@ skipping 31 matching lines @@
 
       AppCacheUpdateJob* update =
           new AppCacheUpdateJob(service_.get(), group_.get());
       group_->update_job_ = update;
       update->StartUpdate(&host4, GURL());
 
       // Verify state after starting an update.
       EXPECT_EQ(AppCacheUpdateJob::UPGRADE_ATTEMPT, update->update_type_);
       EXPECT_EQ(AppCacheUpdateJob::FETCH_MANIFEST, update->internal_state_);
       EXPECT_EQ(AppCacheGroup::CHECKING, group_->update_status());
+      EXPECT_FALSE(update->doing_full_update_check_);
 
       // Verify notifications.
       MockFrontend::RaisedEvents& events = mock_frontend1.raised_events_;
       size_t expected = 1;
       EXPECT_EQ(expected, events.size());
       expected = 2;  // 2 hosts using frontend1
       EXPECT_EQ(expected, events[0].first.size());
       MockFrontend::HostIds& host_ids = events[0].first;
       EXPECT_TRUE(std::find(host_ids.begin(), host_ids.end(), host1.host_id())
           != host_ids.end());
@@ skipping 38 matching lines @@
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                APPCACHE_CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void UpgradeFetchManifestFailTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     MakeService();
-    group_ = new AppCacheGroup(service_->storage(), GURL("http://failme"),
+    group_ = new AppCacheGroup(service_->storage(),
+                               MockHttpServer::GetMockUrl("files/servererror"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
+    group_->set_last_full_update_check_time(
+        base::Time::Now() - kFullUpdateInterval - kOneHour);
     update->StartUpdate(NULL, GURL());
+    EXPECT_TRUE(update->doing_full_update_check_);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
+    expect_evictable_error_ = true;
     expect_newest_cache_ = cache;  // newest cache unaffected by update
+    expect_full_update_time_equal_to_ = group_->last_full_update_check_time();
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, APPCACHE_CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, APPCACHE_ERROR_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, APPCACHE_CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, APPCACHE_ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
@@ skipping 161 matching lines @@
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
+    group_->set_last_full_update_check_time(
+        base::Time::Now() - kFullUpdateInterval - kOneHour);
+    group_->set_first_evictable_error_time(base::Time::Now());
     update->StartUpdate(NULL, GURL());
+    EXPECT_TRUE(update->doing_full_update_check_);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_newest_cache_ = cache;  // newest cache unaffected by update
+    expect_evictable_error_ = false;   // should be reset
+    expect_full_update_time_newer_than_ = group_->last_full_update_check_time();
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, APPCACHE_CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, APPCACHE_NO_UPDATE_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, APPCACHE_CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, APPCACHE_NO_UPDATE_EVENT);
 
     WaitForUpdateToFinish();
   }
 
@@ skipping 93 matching lines @@
 
   void BasicCacheAttemptSuccessTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     GURL manifest_url = MockHttpServer::GetMockUrl("files/manifest1");
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), manifest_url,
         service_->storage()->NewGroupId());
+    ASSERT_TRUE(group_->last_full_update_check_time().is_null());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
+    expect_full_update_time_newer_than_ = base::Time::Now() - kOneHour;
     tested_manifest_ = MANIFEST1;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                APPCACHE_CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void DownloadInterceptEntriesTest() {
     // Ensures we download intercept entries too.
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
@@ skipping 41 matching lines @@
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(),
                                         response_writer_->response_id());
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
     frontend1->SetVerifyProgressEvents(true);
     frontend2->SetVerifyProgressEvents(true);
+    group_->set_last_full_update_check_time(
+        base::Time::Now() - kFullUpdateInterval - kOneHour);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_old_cache_ = cache;
     tested_manifest_ = MANIFEST1;
+    expect_full_update_time_newer_than_ = group_->last_full_update_check_time();
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, APPCACHE_CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, APPCACHE_DOWNLOADING_EVENT);
     frontend1->AddExpectedEvent(ids1, APPCACHE_PROGRESS_EVENT);
     frontend1->AddExpectedEvent(ids1, APPCACHE_PROGRESS_EVENT);
     frontend1->AddExpectedEvent(ids1, APPCACHE_PROGRESS_EVENT);  // final
     frontend1->AddExpectedEvent(ids1, APPCACHE_UPDATE_READY_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, APPCACHE_CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, APPCACHE_DOWNLOADING_EVENT);
@@ skipping 278 matching lines @@
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest-fb-404"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 99);
+    group_->set_first_evictable_error_time(
+        base::Time::Now() - kMaxEvictableErrorDuration - kOneHour);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     frontend1->SetIgnoreProgressEvents(true);
     frontend2->SetIgnoreProgressEvents(true);
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCompleteCache(cache);
     host2->AssociateCompleteCache(cache);
 
     update->StartUpdate(NULL, GURL());
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_newest_cache_ = cache;  // newest cache unaffectd by failed update
+    expect_eviction_ = true;
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, APPCACHE_CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, APPCACHE_DOWNLOADING_EVENT);
     frontend1->AddExpectedEvent(ids1, APPCACHE_ERROR_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, APPCACHE_CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, APPCACHE_DOWNLOADING_EVENT);
     frontend2->AddExpectedEvent(ids2, APPCACHE_ERROR_EVENT);
 
     WaitForUpdateToFinish();
@@ skipping 1245 matching lines @@
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     HttpHeadersRequestTestJob::Initialize("Sat, 29 Oct 1994 19:43:31 GMT",
                                           std::string());
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
-    group_ =new AppCacheGroup(
+    group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Give the newest cache a manifest enry that is in storage.
     response_writer_.reset(
         service_->storage()->CreateResponseWriter(group_->manifest_url(),
@@ skipping 278 matching lines @@
 
   AppCache* MakeCacheForGroup(int64 cache_id, int64 manifest_response_id) {
     return MakeCacheForGroup(cache_id, group_->manifest_url(),
                              manifest_response_id);
   }
 
   AppCache* MakeCacheForGroup(int64 cache_id, const GURL& manifest_entry_url,
                               int64 manifest_response_id) {
     AppCache* cache = new AppCache(service_->storage(), cache_id);
     cache->set_complete(true);
-    cache->set_update_time(base::Time::Now());
+    cache->set_update_time(base::Time::Now() - kOneHour);
     group_->AddCache(cache);
+    group_->set_last_full_update_check_time(cache->update_time());
 
     // Add manifest entry to cache.
     cache->AddEntry(manifest_entry_url,
         AppCacheEntry(AppCacheEntry::MANIFEST, manifest_response_id));
 
+    // Specific tests that expect a newer time should set
+    // expect_full_update_time_newer_than_ which causes this
+    // equality expectation to be ignored.
+    expect_full_update_time_equal_to_ = cache->update_time();
+
     return cache;
   }
 
   AppCacheHost* MakeHost(int host_id, AppCacheFrontend* frontend) {
     AppCacheHost* host = new AppCacheHost(host_id, frontend, service_.get());
     hosts_.push_back(host);
     return host;
   }
 
   AppCacheResponseInfo* MakeAppCacheResponseInfo(
@@ skipping 14 matching lines @@
     return frontend;
   }
 
   // Verifies conditions about the group and notifications after an update
   // has finished. Cannot verify update job internals as update is deleted.
   void VerifyExpectations() {
     RetryRequestTestJob::Verify();
     HttpHeadersRequestTestJob::Verify();
 
     EXPECT_EQ(expect_group_obsolete_, group_->is_obsolete());
-    EXPECT_EQ(expect_group_is_being_deleted_, group_->is_being_deleted());
+    EXPECT_EQ(expect_group_is_being_deleted_ || expect_eviction_,
+              group_->is_being_deleted());
+
+    if (!expect_eviction_) {
+      EXPECT_EQ(expect_evictable_error_,
+                !group_->first_evictable_error_time().is_null());
+      if (expect_evictable_error_) {
+        MockAppCacheStorage* storage =
+            reinterpret_cast<MockAppCacheStorage*>(service_->storage());
+        EXPECT_EQ(group_->first_evictable_error_time(),
+                  storage->stored_eviction_times_[group_->group_id()].second);
+      }
+    }
+
+    if (!expect_full_update_time_newer_than_.is_null()) {
+      EXPECT_LT(expect_full_update_time_newer_than_,
+                group_->last_full_update_check_time());
+    } else if (!expect_full_update_time_equal_to_.is_null()) {
+      EXPECT_EQ(expect_full_update_time_equal_to_,
+                group_->last_full_update_check_time());
+    }
 
     if (expect_group_has_cache_) {
       EXPECT_TRUE(group_->newest_complete_cache() != NULL);
 
       if (expect_non_null_update_time_)
         EXPECT_TRUE(!group_->newest_complete_cache()->update_time().is_null());
 
       if (expect_old_cache_) {
         EXPECT_NE(expect_old_cache_, group_->newest_complete_cache());
         EXPECT_TRUE(group_->old_caches().end() !=
@@ skipping 282 matching lines @@
 
   // Response infos used by an async test that need to live until update job
   // finishes.
   std::vector<scoped_refptr<AppCacheResponseInfo> > response_infos_;
 
   // Flag indicating if test cares to verify the update after update finishes.
   bool do_checks_after_update_finished_;
   bool expect_group_obsolete_;
   bool expect_group_has_cache_;
   bool expect_group_is_being_deleted_;
+  bool expect_evictable_error_;
+  bool expect_eviction_;
+  base::Time expect_full_update_time_newer_than_;
+  base::Time expect_full_update_time_equal_to_;
   AppCache* expect_old_cache_;
   AppCache* expect_newest_cache_;
   bool expect_non_null_update_time_;
   std::vector<MockFrontend*> frontends_;  // to check expected events
   TestedManifest tested_manifest_;
   const char* tested_manifest_path_override_;
   AppCache::EntryMap expect_extra_entries_;
   std::map<GURL, int64> expect_response_ids_;
 };
 
@@ skipping 267 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace content