Workaround for a crashing appcache bug seen on the crash servers

webkit/appcache/appcache_update_job.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 "webkit/appcache/appcache_update_job.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "webkit/appcache/appcache_group.h"
+#include "webkit/appcache/appcache_histograms.h"
 
 namespace appcache {
 
 static const int kBufferSize = 32768;
 static const size_t kMaxConcurrentUrlFetches = 2;
 static const int kMax503Retries = 3;
 
 // Helper class for collecting hosts per frontend when sending notifications
 // so that only one notification is sent for all hosts using the same frontend.
 class HostNotifier {
@@ skipping 258 matching lines @@
   }
   ++retry_503_attempts_;
   request_.reset(new net::URLRequest(url_, this));
   Start();
   return true;
 }
 
 AppCacheUpdateJob::AppCacheUpdateJob(AppCacheService* service,
                                      AppCacheGroup* group)
     : service_(service),
+      manifest_url_(group->manifest_url()),
       group_(group),
       update_type_(UNKNOWN_TYPE),
       internal_state_(FETCH_MANIFEST),
       master_entries_completed_(0),
       url_fetches_completed_(0),
       manifest_fetcher_(NULL),
       stored_state_(UNSTORED) {
-  DCHECK(group_);
-  manifest_url_ = group_->manifest_url();
 }
 
 AppCacheUpdateJob::~AppCacheUpdateJob() {
   if (internal_state_ != COMPLETED)
     Cancel();
 
   DCHECK(!manifest_fetcher_);
   DCHECK(pending_url_fetches_.empty());
   DCHECK(!inprogress_cache_);
   DCHECK(pending_master_entries_.empty());
@@ skipping 428 matching lines @@
 
 void AppCacheUpdateJob::StoreGroupAndCache() {
   DCHECK(stored_state_ == UNSTORED);
   stored_state_ = STORING;
   scoped_refptr<AppCache> newest_cache;
   if (inprogress_cache_)
     newest_cache.swap(inprogress_cache_);
   else
     newest_cache = group_->newest_complete_cache();
   newest_cache->set_update_time(base::Time::Now());
+
+  // TODO(michaeln): dcheck is fishing for clues to crbug/95101
+  DCHECK_EQ(manifest_url_, group_->manifest_url());
   service_->storage()->StoreGroupAndNewestCache(group_, newest_cache,
                                                 this);  // async
 }
 
 void AppCacheUpdateJob::OnGroupAndNewestCacheStored(AppCacheGroup* group,
                                                     AppCache* newest_cache,
                                                     bool success,
                                                     bool would_exceed_quota) {
   DCHECK(stored_state_ == STORING);
   if (success) {
@@ skipping 71 matching lines @@
   PendingHosts& hosts = found->second;
   PendingHosts::iterator it = std::find(hosts.begin(), hosts.end(), host);
   DCHECK(it != hosts.end());
   hosts.erase(it);
 }
 
 void AppCacheUpdateJob::CheckIfManifestChanged() {
   DCHECK(update_type_ == UPGRADE_ATTEMPT);
   AppCacheEntry* entry =
       group_->newest_complete_cache()->GetEntry(manifest_url_);
-  DCHECK(entry);
+  if (!entry) {
+    // TODO(michaeln): This is just a bandaid to avoid a crash.
+    // http://code.google.com/p/chromium/issues/detail?id=95101
+    HandleCacheFailure("Manifest entry not found in existing cache");
+    AppCacheHistograms::AddMissingManifestEntrySample();
+    service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
+    return;
+  }
 
   // Load manifest data from storage to compare against fetched manifest.
   manifest_response_reader_.reset(
       service_->storage()->CreateResponseReader(manifest_url_,
                                                 group_->group_id(),
                                                 entry->response_id()));
   read_manifest_buffer_ = new net::IOBuffer(kBufferSize);
   manifest_response_reader_->ReadData(
       read_manifest_buffer_, kBufferSize,
       base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete,
@@ skipping 472 matching lines @@
 
   // Break the connection with the group so the group cannot call delete
   // on this object after we've posted a task to delete ourselves.
   group_->SetUpdateStatus(AppCacheGroup::IDLE);
   group_ = NULL;
 
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace appcache