Add invalidation to url_response_disk_cache.

services/url_response_disk_cache/url_response_disk_cache_db.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_db.h"
 
 #include <string.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 150 matching lines @@
   return version;
 }
 
 void URLResponseDiskCacheDB::SetVersion(uint64_t version) {
   leveldb::Status status = db_->Put(
       leveldb::WriteOptions(), kVersionKey,
       leveldb::Slice(reinterpret_cast<char*>(&version), sizeof(version)));
   DCHECK(status.ok());
 }
 
-void URLResponseDiskCacheDB::PutNew(const std::string& request_origin,
-                                    const std::string& url,
-                                    CacheEntryPtr entry) {
-  CacheKeyPtr key = CacheKey::New();
-  key->request_origin = request_origin;
-  key->url = url;
-  key->timestamp = base::Time::Now().ToInternalValue();
+void URLResponseDiskCacheDB::Put(CacheKeyPtr key, CacheEntryPtr entry) {
   std::string key_string;
   Serialize(key.Pass(), &key_string);
   std::string entry_string;
   Serialize(entry.Pass(), &entry_string);
   leveldb::Status s =
       db_->Put(leveldb::WriteOptions(), key_string, entry_string);
   DCHECK(s.ok());
 }
 
+CacheEntryPtr URLResponseDiskCacheDB::Get(CacheKeyPtr key) {
+  std::string key_string;
+  std::string entry_string;
+  Serialize(key.Pass(), &key_string);
+  leveldb::Status status =
+      db_->Get(leveldb::ReadOptions(), key_string, &entry_string);
+  if (status.IsNotFound())
+    return CacheEntryPtr();
+  DCHECK(status.ok());
+  CacheEntryPtr result;
+  Deserialize(entry_string, &result);
+  return result.Pass();
+}
+
+void URLResponseDiskCacheDB::PutNew(const std::string& request_origin,
+                                    const std::string& url,
+                                    CacheEntryPtr entry) {
+  CacheKeyPtr key = CacheKey::New();
+  key->request_origin = request_origin;
+  key->url = url;
+  key->timestamp = base::Time::Now().ToInternalValue();
+  Put(key.Pass(), entry.Pass());
+}
+
 CacheEntryPtr URLResponseDiskCacheDB::GetNewest(
     const std::string& request_origin,
-    const std::string& url) {
+    const std::string& url,
+    CacheKeyPtr* output_key) {
   CacheKeyPtr key = CacheKey::New();
   key->request_origin = request_origin;
   key->url = url;
   key->timestamp = std::numeric_limits<int64>::max();
   std::string key_string;
   Serialize(key.Pass(), &key_string);
   scoped_ptr<leveldb::Iterator> it(db_->NewIterator(leveldb::ReadOptions()));
   it->Seek(key_string);
   CacheEntryPtr result;
   if (it->Valid()) {
     Deserialize(it->key(), &key);
     if (key->request_origin == request_origin && key->url == url) {
       Deserialize(it->value(), &result);
+      if (output_key) {
+        *output_key = key.Pass();
+      }
     }
   }
   return result.Pass();
 }
 
 void URLResponseDiskCacheDB::Delete(CacheKeyPtr key) {
   std::string key_string;
   Serialize(key.Pass(), &key_string);
   leveldb::Status s = db_->Delete(leveldb::WriteOptions(), key_string);
   DCHECK(s.ok());
 }
 
 scoped_ptr<URLResponseDiskCacheDB::Iterator>
 URLResponseDiskCacheDB::GetIterator() {
   return make_scoped_ptr(new Iterator(db_));
 }
 
 URLResponseDiskCacheDB::~URLResponseDiskCacheDB() {}
 
 }  // namespace mojo