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/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_context.h"
 
 namespace content {
 
-static const int kBufferSize = 32768;
-static const size_t kMaxConcurrentUrlFetches = 2;
-static const int kMax503Retries = 3;
+namespace {
 
-static std::string FormatUrlErrorMessage(
+const int kBufferSize = 32768;
+const size_t kMaxConcurrentUrlFetches = 2;
+const int kMax503Retries = 3;
+
+std::string FormatUrlErrorMessage(
       const char* format, const GURL& url,
       AppCacheUpdateJob::ResultType error,
       int response_code) {
     // Show the net response code if we have one.
     int code = response_code;
     if (error != AppCacheUpdateJob::SERVER_ERROR)
       code = static_cast<int>(error);
     return base::StringPrintf(format, code, url.spec().c_str());
 }
 
+bool IsEvictableError(AppCacheUpdateJob::ResultType result,
+                      const AppCacheErrorDetails& details) {
+  switch (result) {
+    case AppCacheUpdateJob::DB_ERROR:
+    case AppCacheUpdateJob::DISKCACHE_ERROR:
+    case AppCacheUpdateJob::QUOTA_ERROR:
+    case AppCacheUpdateJob::NETWORK_ERROR:
+    case AppCacheUpdateJob::CANCELLED_ERROR:
+      return false;
+
+    case AppCacheUpdateJob::REDIRECT_ERROR:
+    case AppCacheUpdateJob::SERVER_ERROR:
+    case AppCacheUpdateJob::SECURITY_ERROR:
+      return true;
+
+    case AppCacheUpdateJob::MANIFEST_ERROR:
+      return details.reason == APPCACHE_SIGNATURE_ERROR;
+
+    default:
+      NOTREACHED();
+      return true;
+  }
+}
+
+void EmptyCompletionCallback(int result) {}
+
+}  // namespace
+
 // 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 {
  public:
   typedef std::vector<int> HostIds;
   typedef std::map<AppCacheFrontend*, HostIds> NotifyHostMap;
 
   // Caller is responsible for ensuring there will be no duplicate hosts.
   void AddHost(AppCacheHost* host) {
     std::pair<NotifyHostMap::iterator , bool> ret = hosts_to_notify.insert(
@@ skipping 75 matching lines @@
       request_(job->service_->request_context()
                    ->CreateRequest(url, net::DEFAULT_PRIORITY, this)),
       result_(UPDATE_OK),
       redirect_response_code_(-1) {}
 
 AppCacheUpdateJob::URLFetcher::~URLFetcher() {
 }
 
 void AppCacheUpdateJob::URLFetcher::Start() {
   request_->set_first_party_for_cookies(job_->manifest_url_);
-  if (existing_response_headers_.get())
+  if (fetch_type_ == MANIFEST_FETCH && job_->doing_full_update_check_)
+    request_->SetLoadFlags(request_->load_flags() | net::LOAD_BYPASS_CACHE);
+  else if (existing_response_headers_.get())
     AddConditionalHeaders(existing_response_headers_.get());
   request_->Start();
 }
 
 void AppCacheUpdateJob::URLFetcher::OnReceivedRedirect(
     net::URLRequest* request,
     const net::RedirectInfo& redirect_info,
     bool* defer_redirect) {
   DCHECK(request_ == request);
   // Redirect is not allowed by the update process.
@@ skipping 202 matching lines @@
   return true;
 }
 
 AppCacheUpdateJob::AppCacheUpdateJob(AppCacheServiceImpl* service,
                                      AppCacheGroup* group)
     : service_(service),
       manifest_url_(group->manifest_url()),
       group_(group),
       update_type_(UNKNOWN_TYPE),
       internal_state_(FETCH_MANIFEST),
+      doing_full_update_check_(false),
       master_entries_completed_(0),
       url_fetches_completed_(0),
       manifest_fetcher_(NULL),
       manifest_has_valid_mime_type_(false),
       stored_state_(UNSTORED),
       storage_(service->storage()),
       weak_factory_(this) {
     service_->AddObserver(this);
 }
 
@@ skipping 54 matching lines @@
       }
     }
     return;
   }
 
   // Begin update process for the group.
   MadeProgress();
   group_->SetUpdateAppCacheStatus(AppCacheGroup::CHECKING);
   if (group_->HasCache()) {
     update_type_ = UPGRADE_ATTEMPT;
+    base::TimeDelta time_since_last_check =
+        base::Time::Now() - group_->last_full_update_check_time();
+    doing_full_update_check_ =
+        time_since_last_check > base::TimeDelta::FromHours(24);
     NotifyAllAssociatedHosts(APPCACHE_CHECKING_EVENT);
   } else {
     update_type_ = CACHE_ATTEMPT;
+    doing_full_update_check_ = true;
     DCHECK(host);
     NotifySingleHost(host, APPCACHE_CHECKING_EVENT);
   }
 
   if (!new_master_resource.is_empty()) {
     AddMasterEntryToFetchList(host, new_master_resource,
                               is_new_pending_master_entry);
   }
 
   BrowserThread::PostAfterStartupTask(
@@ skipping 18 matching lines @@
   DCHECK(internal_state_ != CACHE_FAILURE);
   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;
+
+  if (update_type_ == CACHE_ATTEMPT ||
+      !IsEvictableError(result, error_details) ||
+      service_->storage() != storage_) {
+    DeleteSoon();
+    return;
+  }
+
+  if (group_->first_evictable_error_time().is_null()) {
+    group_->set_first_evictable_error_time(base::Time::Now());
+    storage_->StoreEvictionTimes(group_);
+    DeleteSoon();
+    return;
+  }
+
+  base::TimeDelta error_duration =
+      base::Time::Now() - group_->first_evictable_error_time();
+  base::TimeDelta kMaxPersistentErrorDuration = base::TimeDelta::FromDays(4);
+  if (error_duration > kMaxPersistentErrorDuration) {
+    // Break the connection with the group prior to calling
+    // DeleteAppCacheGroup, otherwise that method would delete |this|
+    // and we need the stack to unwind prior to deletion.
+    group_->SetUpdateAppCacheStatus(AppCacheGroup::IDLE);
+    group_ = NULL;
+    service_->DeleteAppCacheGroup(manifest_url_,
+                                  base::Bind(EmptyCompletionCallback));
+  }
+
   DeleteSoon();  // To unwind the stack prior to deletion.
 }
 
 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);
 
-  // Add any necessary Http headers before sending fetch request.
   if (is_first_fetch) {
+    // Maybe load the cached headers to make a condiditional request.
     AppCacheEntry* entry = (update_type_ == UPGRADE_ATTEMPT) ?
         group_->newest_complete_cache()->GetEntry(manifest_url_) : NULL;
-    if (entry) {
+    if (entry && !doing_full_update_check_) {
       // Asynchronously load response info for manifest from newest cache.
       storage_->LoadResponseInfo(manifest_url_, group_->group_id(),
                                  entry->response_id(), this);
-    } else {
-      manifest_fetcher_->Start();
+      return;

[jsbell, 2015/05/27 22:38:18]

Much nicer code flow here!

[michaeln, 2015/05/27 23:21:51]

yup, i put in some early returns elsewhere too for that reason

     }
-  } else {
-    DCHECK(internal_state_ == REFETCH_MANIFEST);
-    DCHECK(manifest_response_info_.get());
-    manifest_fetcher_->set_existing_response_headers(
-        manifest_response_info_->headers.get());
     manifest_fetcher_->Start();
+    return;
   }
+
+  DCHECK(internal_state_ == REFETCH_MANIFEST);
+  DCHECK(manifest_response_info_.get());
+  manifest_fetcher_->set_existing_response_headers(
+      manifest_response_info_->headers.get());
+  manifest_fetcher_->Start();
 }
 
 
 void AppCacheUpdateJob::HandleManifestFetchCompleted(
     URLFetcher* fetcher) {
   DCHECK_EQ(internal_state_, FETCH_MANIFEST);
   DCHECK_EQ(manifest_fetcher_, fetcher);
   manifest_fetcher_ = NULL;
 
   net::URLRequest* request = fetcher->request();
@@ skipping 47 matching lines @@
       response_code,
       false /*is_cross_origin*/));
   if (success) {
     DCHECK(group->is_obsolete());
     NotifyAllAssociatedHosts(APPCACHE_OBSOLETE_EVENT);
     internal_state_ = COMPLETED;
     MaybeCompleteUpdate();
   } else {
     // Treat failure to mark group obsolete as a cache failure.
     HandleCacheFailure(AppCacheErrorDetails(
-        "Failed to mark the cache as obsolete",
-        APPCACHE_UNKNOWN_ERROR,
-        GURL(),
-        0,
-        false /*is_cross_origin*/),
+                           "Failed to mark the cache as obsolete",
+                           APPCACHE_UNKNOWN_ERROR, GURL(),  0,
+                           false /*is_cross_origin*/),
                        DB_ERROR,
                        GURL());
   }
 }
 
 void AppCacheUpdateJob::ContinueHandleManifestFetchCompleted(bool changed) {
   DCHECK(internal_state_ == FETCH_MANIFEST);
 
   if (!changed) {
     DCHECK(update_type_ == UPGRADE_ATTEMPT);
@@ skipping 339 matching lines @@
                      0,
                      false /*is_cross_origin*/),
         DISKCACHE_ERROR,
         GURL());
   }
 }
 
 void AppCacheUpdateJob::StoreGroupAndCache() {
   DCHECK(stored_state_ == UNSTORED);
   stored_state_ = STORING;
+
   scoped_refptr<AppCache> newest_cache;
   if (inprogress_cache_.get())
     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());
+  group_->set_first_evictable_error_time(base::Time());
+  if (doing_full_update_check_)
+    group_->set_last_full_update_check_time(base::Time::Now());
+
   storage_->StoreGroupAndNewestCache(group_, newest_cache.get(), this);
 }
 
 void AppCacheUpdateJob::OnGroupAndNewestCacheStored(AppCacheGroup* group,
                                                     AppCache* newest_cache,
                                                     bool success,
                                                     bool would_exceed_quota) {
   DCHECK(stored_state_ == STORING);
   if (success) {
     stored_state_ = STORED;
     MaybeCompleteUpdate();  // will definitely complete
-  } else {
-    stored_state_ = UNSTORED;
+    return;
+  }
+
+  stored_state_ = UNSTORED;
 
     // Restore inprogress_cache_ to get the proper events delivered
     // and the proper cleanup to occur.
     if (newest_cache != group->newest_complete_cache())
       inprogress_cache_ = newest_cache;
 
     ResultType result = DB_ERROR;
     AppCacheErrorReason reason = APPCACHE_UNKNOWN_ERROR;
     std::string message("Failed to commit new cache to storage");
     if (would_exceed_quota) {
       message.append(", would exceed quota");
       result = QUOTA_ERROR;
       reason = APPCACHE_QUOTA_ERROR;
     }
     HandleCacheFailure(
         AppCacheErrorDetails(message, reason, GURL(), 0,
             false /*is_cross_origin*/),
         result,
         GURL());
-  }
 }
 
 void AppCacheUpdateJob::NotifySingleHost(AppCacheHost* host,
                                          AppCacheEventID event_id) {
   std::vector<int> ids(1, host->host_id());
   host->frontend()->OnEventRaised(ids, event_id);
 }
 
 void AppCacheUpdateJob::NotifyAllAssociatedHosts(AppCacheEventID event_id) {
   HostNotifier host_notifier;
@@ skipping 461 matching lines @@
       if (master_entries_completed_ > 0) {
         switch (stored_state_) {
           case UNSTORED:
             StoreGroupAndCache();
             return;
           case STORING:
             return;
           case STORED:
             break;
         }
+      } else {
+        bool times_changed = false;
+        if (!group_->first_evictable_error_time().is_null()) {
+          group_->set_first_evictable_error_time(base::Time());
+          times_changed = true;
+        }
+        if (doing_full_update_check_) {
+          group_->set_last_full_update_check_time(base::Time::Now());
+          times_changed = true;
+        }
+        if (times_changed)
+          storage_->StoreEvictionTimes(group_);
       }
       // 6.9.4 steps 7.3-7.7.
       NotifyAllAssociatedHosts(APPCACHE_NO_UPDATE_EVENT);
       DiscardDuplicateResponses();
       internal_state_ = COMPLETED;
       break;
     case DOWNLOADING:
       internal_state_ = REFETCH_MANIFEST;
       FetchManifest(false);
       break;
@@ skipping 141 matching lines @@
 
 void AppCacheUpdateJob::DeleteSoon() {
   ClearPendingMasterEntries();
   manifest_response_writer_.reset();
   storage_->CancelDelegateCallbacks(this);
   service_->RemoveObserver(this);
   service_ = NULL;
 
   // 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;
+  if (group_) {
+    group_->SetUpdateAppCacheStatus(AppCacheGroup::IDLE);
+    group_ = NULL;
+  }
 
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace content