Add invalidation to url_response_disk_cache.

services/url_response_disk_cache/url_response_disk_cache_impl.cc

 // Copyright 2015 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 "services/url_response_disk_cache/url_response_disk_cache_impl.h"
 
 #include <dirent.h>
 #include <fcntl.h>
 #include <sys/types.h>
 
@@ skipping 17 matching lines @@
 #include "services/url_response_disk_cache/url_response_disk_cache_entry.mojom.h"
 #include "third_party/zlib/google/zip_reader.h"
 #include "url/gurl.h"
 
 namespace mojo {
 
 namespace {
 
 // The current version of the cache. This should only be incremented. When this
 // is incremented, all current cache entries will be invalidated.
-const uint32_t kCurrentVersion = 0;
+const uint32_t kCurrentVersion = 1;
 
 // The delay to wait before starting deleting data. This is delayed to not
 // interfere with the shell startup.
 const uint32_t kTrashDelayInSeconds = 60;
 
+// The delay between the time an entry is invalidated and the cache not
+// returning it anymore.
+const uint32_t kTimeUntilInvalidationInSeconds = 90;
+
 const char kEtagHeader[] = "etag";
 
 // Create a new identifier for a cache entry. This will be used as an unique
 // directory name.
 std::string GetNewIdentifier() {
   char bytes[32];
   crypto::RandBytes(bytes, arraysize(bytes));
   return base::HexEncode(bytes, arraysize(bytes));
 }
 
@@ skipping 114 matching lines @@
       GetStagingDirectory().Append(identifier);
   base::FilePath entry_directory = GetCacheDirectory().Append(identifier);
   base::FilePath response_body_path = entry_directory.Append(identifier);
   base::FilePath consumer_cache_directory =
       GetConsumerCacheDirectory(entry_directory);
 
   CacheEntryPtr entry = CacheEntry::New();
   entry->response = response.Pass();
   entry->entry_directory = entry_directory.value();
   entry->response_body_path = response_body_path.value();
+  entry->last_invalidation = base::Time::Max().ToInternalValue();
 
   db->PutNew(request_origin, url, entry.Pass());
 
   if (!base::CreateDirectoryAndGetError(entry_directory, nullptr) ||
       !base::CreateDirectoryAndGetError(consumer_cache_directory, nullptr) ||
       !base::ReplaceFile(staged_response_body_path, response_body_path,
                          nullptr)) {
     MovePathIntoDir(entry_directory, GetStagingDirectory());
     callback.Run(base::FilePath(), base::FilePath());
     return;
@@ skipping 49 matching lines @@
     return false;
   std::vector<std::string> response_etags =
       GetHeaderValues(etag_header_name, response->headers);
   if (response_etags.size() == 0)
     return false;
 
   // Looking for the first etag header.
   return entry_etags[0] == response_etags[0];
 }
 
+void UpdateLastInvalidation(scoped_refptr<URLResponseDiskCacheDB> db,
+                            CacheKeyPtr key,
+                            const base::Time& time) {
+  CacheEntryPtr entry = db->Get(key.Clone());
+  entry->last_invalidation = time.ToInternalValue();
+  db->Put(key.Pass(), entry.Pass());
+}
+
 void PruneCache(scoped_refptr<URLResponseDiskCacheDB> db,
                 const scoped_ptr<URLResponseDiskCacheDB::Iterator>& iterator) {
   CacheKeyPtr last_key;
   CacheKeyPtr key;
   CacheEntryPtr entry;
   while (iterator->HasNext()) {
     iterator->GetNext(&key, &entry);
     if (last_key && last_key->request_origin == key->request_origin &&
         last_key->url == key->url) {
       base::FilePath entry_directory = base::FilePath(entry->entry_directory);
@@ skipping 53 matching lines @@
     scoped_refptr<URLResponseDiskCacheDB> db,
     const std::string& remote_application_url,
     InterfaceRequest<URLResponseDiskCache> request)
     : task_runner_(task_runner), db_(db), binding_(this, request.Pass()) {
   request_origin_ = GURL(remote_application_url).GetOrigin().spec();
 }
 
 URLResponseDiskCacheImpl::~URLResponseDiskCacheImpl() {
 }
 
+bool IsInvalidated(const CacheEntryPtr& entry) {
+  if (!entry)
+    return true;
+  return base::Time::Now() -
+             base::Time::FromInternalValue(entry->last_invalidation) >
+         base::TimeDelta::FromSeconds(kTimeUntilInvalidationInSeconds);
+}
+
 void URLResponseDiskCacheImpl::Get(const String& url,
                                    const GetCallback& callback) {
-  CacheEntryPtr entry = db_->GetNewest(request_origin_, CanonicalizeURL(url));
-  if (!IsCacheEntryValid(entry)) {
+  CacheKeyPtr key;
+  CacheEntryPtr entry =
+      db_->GetNewest(request_origin_, CanonicalizeURL(url), &key);
+  if (IsInvalidated(entry) || !IsCacheEntryValid(entry)) {
     callback.Run(URLResponsePtr(), Array<uint8_t>(), Array<uint8_t>());
     return;
   }
   callback.Run(entry->response.Pass(),
                PathToArray(base::FilePath(entry->response_body_path)),
                PathToArray(GetConsumerCacheDirectory(
                    base::FilePath(entry->entry_directory))));
+  UpdateLastInvalidation(db_, key.Pass(), base::Time::Now());
+}
+
+void URLResponseDiskCacheImpl::Validate(const String& url) {
+  CacheKeyPtr key;
+  CacheEntryPtr entry =
+      db_->GetNewest(request_origin_, CanonicalizeURL(url), &key);
+  if (entry)
+    UpdateLastInvalidation(db_, key.Pass(), base::Time::Max());
 }
 
 void URLResponseDiskCacheImpl::Update(URLResponsePtr response) {
   UpdateAndGetInternal(response.Pass(), base::Bind(&DoNothing));
 }
 
 void URLResponseDiskCacheImpl::UpdateAndGet(
     URLResponsePtr response,
     const UpdateAndGetCallback& callback) {
   UpdateAndGetInternal(response.Pass(), base::Bind(&RunMojoCallback, callback));
 }
 
 void URLResponseDiskCacheImpl::UpdateAndGetExtracted(
     URLResponsePtr response,
     const UpdateAndGetExtractedCallback& callback) {
-  if (response->error ||
-      (response->status_code >= 400 && response->status_code < 600)) {
-    callback.Run(Array<uint8_t>(), Array<uint8_t>());
-    return;
-  }
-
-  std::string url = CanonicalizeURL(response->url);
-
-  // Check if the response is cached and valid. If that's the case, returns the
-  // cached value.
-  CacheEntryPtr entry = db_->GetNewest(request_origin_, url);
-
-  if (!IsCacheEntryFresh(response, entry)) {
-    UpdateAndGetInternal(
-        response.Pass(),
-        base::Bind(&URLResponseDiskCacheImpl::UpdateAndGetExtractedInternal,
-                   base::Unretained(this),
-                   base::Bind(&RunMojoCallback, callback)));
-    return;
-  }
-
-  base::FilePath entry_directory = base::FilePath(entry->entry_directory);
-  base::FilePath extraction_directory = GetExtractionDirectory(entry_directory);
-  if (!PathExists(GetExtractionSentinel(entry_directory))) {
-    UpdateAndGetExtractedInternal(base::Bind(&RunMojoCallback, callback),
-                                  base::FilePath(entry->response_body_path),
-                                  GetConsumerCacheDirectory(entry_directory));
-    return;
-  }
-
-  callback.Run(PathToArray(extraction_directory),
-               PathToArray(GetConsumerCacheDirectory(entry_directory)));
+  UpdateAndGetInternal(
+      response.Pass(),
+      base::Bind(&URLResponseDiskCacheImpl::UpdateAndGetExtractedInternal,
+                 base::Unretained(this),
+                 base::Bind(&RunMojoCallback, callback)));
 }
 
 void URLResponseDiskCacheImpl::UpdateAndGetInternal(
     URLResponsePtr response,
     const ResponseFileAndCacheDirCallback& callback) {
   if (response->error ||
       (response->status_code >= 400 && response->status_code < 600)) {
     callback.Run(base::FilePath(), base::FilePath());
     return;
   }
 
   std::string url = CanonicalizeURL(response->url);
 
   // Check if the response is cached and valid. If that's the case, returns
   // the cached value.
-  CacheEntryPtr entry = db_->GetNewest(request_origin_, url);
+  CacheKeyPtr key;
+  CacheEntryPtr entry = db_->GetNewest(request_origin_, url, &key);
   if (IsCacheEntryFresh(response, entry)) {
     callback.Run(
         base::FilePath(entry->response_body_path),
         GetConsumerCacheDirectory(base::FilePath(entry->entry_directory)));
+    UpdateLastInvalidation(db_, key.Pass(), base::Time::Max());
     return;
   }
 
   if (!response->body.is_valid()) {
     callback.Run(base::FilePath(), base::FilePath());
     return;
   }
 
   std::string identifier = GetNewIdentifier();
   // The content is copied to the staging directory so that files are not leaked
@@ skipping 57 matching lines @@
       return;
     }
   }
   // We can ignore write error, as it will just force to clear the cache on the
   // next request.
   WriteFile(GetExtractionSentinel(entry_directory), nullptr, 0);
   callback.Run(extraction_directory, consumer_cache_directory);
 }
 
 }  // namespace mojo