After 24 hours, bust the browser cache when checking for ServiceWorker updates

content/browser/service_worker/service_worker_context_request_handler.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 "content/browser/service_worker/service_worker_context_request_handler.h"
 
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_read_from_cache_job.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/browser/service_worker/service_worker_write_to_cache_job.h"
+#include "net/base/load_flags.h"
 #include "net/url_request/url_request.h"
 
 namespace content {
 
 ServiceWorkerContextRequestHandler::ServiceWorkerContextRequestHandler(
     base::WeakPtr<ServiceWorkerContextCore> context,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context,
     ResourceType resource_type)
     : ServiceWorkerRequestHandler(context,
@@ skipping 21 matching lines @@
   // importScripts(), even if a cached script is xhr'd, we don't
   // retrieve it from the script cache.
   // TODO(michaeln): Get the desired behavior clarified in the spec,
   // and make tweak the behavior here to match.
   if (resource_type_ != RESOURCE_TYPE_SERVICE_WORKER &&
       resource_type_ != RESOURCE_TYPE_SCRIPT) {
     return NULL;
   }
 
   if (ShouldAddToScriptCache(request->url())) {
+    ServiceWorkerRegistration* registration =
+        context_->GetLiveRegistration(version_->registration_id());
+    DCHECK(registration);  // We're registering or updating so must be there.
+
     int64 response_id = context_->storage()->NewResourceId();
     if (response_id == kInvalidServiceWorkerResponseId)
       return NULL;
+
+    // Bypass the browser cache for initial installs and update
+    // checks after 24 hours have passed.
+    // TODO(michaeln): When loading imports the last_update_check time has
+    // already been updated by the UPDATE_JOB so we never set the bypass
+    // flag for them, but probably should.
+    int extra_load_flags = 0;
+    base::TimeDelta time_since_last_check =
+        base::Time::Now() - registration->last_update_check();
+    if (time_since_last_check > base::TimeDelta::FromHours(24))
+      extra_load_flags = net::LOAD_BYPASS_CACHE;
+
     return new ServiceWorkerWriteToCacheJob(request,
                                             network_delegate,
                                             resource_type_,
                                             context_,
                                             version_,
+                                            extra_load_flags,
                                             response_id);
   }
 
   int64 response_id = kInvalidServiceWorkerResponseId;
   if (ShouldReadFromScriptCache(request->url(), &response_id)) {
     return new ServiceWorkerReadFromCacheJob(
         request, network_delegate, context_, response_id);
   }
 
   // NULL means use the network.
@@ skipping 22 matching lines @@
     const GURL& url, int64* response_id_out) {
   // We don't read from the script cache until the version is INSTALLED.
   if (version_->status() == ServiceWorkerVersion::NEW ||
       version_->status() == ServiceWorkerVersion::INSTALLING)
     return false;
   *response_id_out = version_->script_cache_map()->Lookup(url);
   return *response_id_out != kInvalidServiceWorkerResponseId;
 }
 
 }  // namespace content