Workaround for a crashing appcache bug seen on the crash servers

webkit/appcache/appcache_update_job_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
@@ skipping 553 matching lines @@
   scoped_refptr<net::URLRequestContext> request_context_;
 };
 
 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_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(MessageLoop::TYPE_IO, 0);
     io_thread_->StartWithOptions(options);
   }
 
@@ skipping 398 matching lines @@
     scoped_refptr<net::StringIOBuffer> io_buffer(
         new net::StringIOBuffer(seed_data));
     response_writer_->WriteData(
         io_buffer, seed_data.length(),
         base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData,
                    base::Unretained(this)));
 
     // Start update after data write completes asynchronously.
   }
 
+  void UpgradeMissingManifestEntryDoesntCrash() {

[jennb, 2012/05/03 18:43:31]

nit: s/Doesnt/DoesNot

[michaeln, 2012/05/03 19:03:25]

Done, renamed to Bug95101Test()

+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(
+        service_.get(), MockHttpServer::GetMockUrl("files/empty-manifest"),
+        service_->storage()->NewGroupId());
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    // Create a malformed cache with a missing manifest entry.
+    GURL wrong_manifest_url =
+        MockHttpServer::GetMockUrl("files/missing-mime-manifest");
+    AppCache* cache = MakeCacheForGroup(1, wrong_manifest_url, 111);
+    MockFrontend* frontend = MakeMockFrontend();
+    AppCacheHost* host = MakeHost(1, frontend);
+    host->AssociateCompleteCache(cache);
+
+    update->StartUpdate(NULL, GURL());
+    EXPECT_TRUE(update->manifest_fetcher_ != NULL);
+
+    // Set up checks for when update job finishes.
+    do_checks_after_update_finished_ = true;
+    expect_group_is_being_deleted_ = true;
+    expect_group_has_cache_ = true;
+    expect_newest_cache_ = cache;  // newest cache unaffected by update
+    MockFrontend::HostIds id(1, host->host_id());
+    frontend->AddExpectedEvent(id, CHECKING_EVENT);
+    frontend->AddExpectedEvent(id, ERROR_EVENT);
+    frontend->expected_error_message_ =
+        "Manifest entry not found in existing cache";
+    WaitForUpdateToFinish();
+  }
+
   void StartUpdateAfterSeedingStorageData(int result) {
     ASSERT_GT(result, 0);
     response_writer_.reset();
 
     AppCacheUpdateJob* update = group_->update_job_;
     update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     WaitForUpdateToFinish();
   }
@@ skipping 1893 matching lines @@
 
     event_->Signal();
   }
 
   void MakeService() {
     service_.reset(new MockAppCacheService());
     service_->set_request_context(io_thread_->request_context());
   }
 
   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_.get(), cache_id);
     cache->set_complete(true);
     cache->set_update_time(base::Time::Now());
     group_->AddCache(cache);
 
     // Add manifest entry to cache.
-    cache->AddEntry(group_->manifest_url(),
+    cache->AddEntry(manifest_entry_url,
         AppCacheEntry(AppCacheEntry::MANIFEST, manifest_response_id));
 
     return cache;
   }
 
   AppCacheHost* MakeHost(int host_id, AppCacheFrontend* frontend) {
     AppCacheHost* host = new AppCacheHost(host_id, frontend, service_.get());
     hosts_.push_back(host);
     return host;
   }
@@ skipping 16 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());
 
     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 278 matching lines @@
   std::vector<AppCacheHost*> hosts_;
 
   // 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_;
   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 96 matching lines @@
 }
 
 TEST_F(AppCacheUpdateJobTest, UpgradeNotModified) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeNotModifiedTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, UpgradeManifestDataUnchanged) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeManifestDataUnchangedTest);
 }
 
+TEST_F(AppCacheUpdateJobTest, UpgradeMissingManifestEntryDoesntCrash) {
+  RunTestOnIOThread(
+      &AppCacheUpdateJobTest::UpgradeMissingManifestEntryDoesntCrash);
+}
+
 TEST_F(AppCacheUpdateJobTest, BasicCacheAttemptSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::BasicCacheAttemptSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, DownloadInterceptEntriesTest) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::DownloadInterceptEntriesTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, BasicUpgradeSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::BasicUpgradeSuccessTest);
@@ skipping 147 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace appcache