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

content/browser/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 "content/browser/appcache/appcache_update_job.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 233 matching lines @@
     DCHECK_EQ(UPDATE_OK, result_);
     OnResponseCompleted();
   }
 }
 
 void AppCacheUpdateJob::URLFetcher::AddConditionalHeaders(
     const net::HttpResponseHeaders* headers) {
   DCHECK(request_.get() && headers);
   net::HttpRequestHeaders extra_headers;
 
+  // TODO(michaeln): skip condition headers on manifest fetches if its been 24 hours
+  // since the last update check
+  // TODO: store date of last update check even that busted the cache
+  // if (firstManifestFetch &&
+  //     now > newest_successful_unconditional_update_check_time + 24hours)
+  //    performing_unconditional_update_check_ = true;
+
   // Add If-Modified-Since header if response info has Last-Modified header.
   const std::string last_modified = "Last-Modified";
   std::string last_modified_value;
   headers->EnumerateHeader(NULL, last_modified, &last_modified_value);
   if (!last_modified_value.empty()) {
     extra_headers.SetHeader(net::HttpRequestHeaders::kIfModifiedSince,
                             last_modified_value);
   }
 
   // Add If-None-Match header if response info has ETag header.
@@ skipping 207 matching lines @@
   DCHECK(!error_details.message.empty());
   DCHECK(result != UPDATE_OK);
   internal_state_ = CACHE_FAILURE;
   LogHistogramStats(result, failed_resource_url);
   CancelAllUrlFetches();
   CancelAllMasterEntryFetches(error_details);
   NotifyAllError(error_details);
   DiscardInprogressCache();
   internal_state_ = COMPLETED;
   DeleteSoon();  // To unwind the stack prior to deletion.
+
+    // TODO(michaeln): Evict the cache under other cicrumstances too
+    // if we've been getting srvr errors for "too long"
+    // if we've been getting srvr redirects for "too long"
+    // if we've been getting an invalid manifest for "too long"
+    // maybe "too long" for http is less than it is for https?

[palmer, 2015/04/21 19:56:34]

Good idea.

+    // TODO: store date of first evictable error since last successfull update check
+    // if (is_an_evictable_error &&
+    //       now > first_evictable_error_since_successfull_check + kTooLong)
+    //   evict();
+    // else if (!first_evictable_error_since_successfull_check) set it to now
 }
 
 void AppCacheUpdateJob::FetchManifest(bool is_first_fetch) {
   DCHECK(!manifest_fetcher_);
   manifest_fetcher_ = new URLFetcher(
      manifest_url_,
      is_first_fetch ? URLFetcher::MANIFEST_FETCH :
                       URLFetcher::MANIFEST_REFETCH,
      this);
 
@@ skipping 43 matching lines @@
     if (update_type_ == UPGRADE_ATTEMPT)
       CheckIfManifestChanged();  // continues asynchronously
     else
       ContinueHandleManifestFetchCompleted(true);
   } else if (response_code == 304 && update_type_ == UPGRADE_ATTEMPT) {
     ContinueHandleManifestFetchCompleted(false);
   } else if ((response_code == 404 || response_code == 410) &&
              update_type_ == UPGRADE_ATTEMPT) {
     storage_->MakeGroupObsolete(group_, this, response_code);  // async
   } else {
+    // TODO(michaeln): Evict the cache under other cicrumstances too.
+    // APPCACHE_MANIFEST_ERROR + networkresponsecde is an evictable error
     const char* kFormatString = "Manifest fetch failed (%d) %s";
     std::string message = FormatUrlErrorMessage(
         kFormatString, manifest_url_, fetcher->result(), response_code);
     HandleCacheFailure(AppCacheErrorDetails(message,
                                     APPCACHE_MANIFEST_ERROR,
                                     manifest_url_,
                                     response_code,
                                     false /*is_cross_origin*/),
                        fetcher->result(),
                        GURL());
@@ skipping 26 matching lines @@
         false /*is_cross_origin*/),
                        DB_ERROR,
                        GURL());
   }
 }
 
 void AppCacheUpdateJob::ContinueHandleManifestFetchCompleted(bool changed) {
   DCHECK(internal_state_ == FETCH_MANIFEST);
 
   if (!changed) {
+    // if unconditional_check, set time to now
     DCHECK(update_type_ == UPGRADE_ATTEMPT);
     internal_state_ = NO_UPDATE;
 
     // Wait for pending master entries to download.
     FetchMasterEntries();
     MaybeCompleteUpdate();  // if not done, run async 6.9.4 step 7 substeps
     return;
   }
 
   AppCacheManifest manifest;
   if (!ParseManifest(manifest_url_, manifest_data_.data(),
                      manifest_data_.length(),
                      manifest_has_valid_mime_type_ ?
                         PARSE_MANIFEST_ALLOWING_INTERCEPTS :
                         PARSE_MANIFEST_PER_STANDARD,
                      manifest)) {
+    // TODO(michaeln): Evict the cache under other cicrumstances too.
+    // APPCACHE_SIGNATURE_ERROR is an evictable error
     const char* kFormatString = "Failed to parse manifest %s";
     const std::string message = base::StringPrintf(kFormatString,
         manifest_url_.spec().c_str());
     HandleCacheFailure(
         AppCacheErrorDetails(
             message, APPCACHE_SIGNATURE_ERROR, GURL(), 0,
             false /*is_cross_origin*/),
         MANIFEST_ERROR,
         GURL());
     VLOG(1) << message;
@@ skipping 1005 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_->SetUpdateAppCacheStatus(AppCacheGroup::IDLE);
   group_ = NULL;
 
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace content