test

content/browser/cache_storage/cache_storage_cache.cc

Index: content/browser/cache_storage/cache_storage_cache.cc
diff --git a/content/browser/cache_storage/cache_storage_cache.cc b/content/browser/cache_storage/cache_storage_cache.cc
index 1e83b43c664c994c7fb37f480d314ae649147e5e..8992a830c8c4d5521c51a1bce9083bde295f01e7 100644
--- a/content/browser/cache_storage/cache_storage_cache.cc
+++ b/content/browser/cache_storage/cache_storage_cache.cc
@@ -506,6 +506,75 @@ bool CacheStorageCache::LazyInitialize() {
   return false;
 }
 
+void CacheStorageCache::QueryCache(scoped_ptr<ServiceWorkerFetchRequest> request,
+                                   const CacheStorageCacheQueryParams& options) {
+  printf("perform query cache\n");
+}
+
+void CacheStorageCache::OpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
+                                  const OpenAllEntriesCallback& callback) {
+  scoped_ptr<OpenAllEntriesContext> entries_context(new OpenAllEntriesContext);
+
+  disk_cache::Entry** entry_ptr = &entries_context->enumerated_entry;
+
+  net::CompletionCallback open_entry_callback = base::Bind(
+      &CacheStorageCache::DidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
+      base::Passed(std::move(entries_context)), callback);
+
+  int rv = backend_->OpenEntry(request.get()->url.spec(), entry_ptr, open_entry_callback);
+  if (rv != net::ERR_IO_PENDING)
+    open_entry_callback.Run(rv);
+}
+
+void CacheStorageCache::DidOpenEntry(scoped_ptr<OpenAllEntriesContext> entries_context,
+                                     const OpenAllEntriesCallback& callback,
+                                     int rv) {
+  if (rv != net::OK) {
+    callback.Run(std::move(entries_context), CACHE_STORAGE_ERROR_NOT_FOUND);
+    return;
+  }
+
+  //DCHECK(entries_context->enumerated_entry);
+
+  // Store the entry.
+  entries_context->entries.push_back(entries_context->enumerated_entry);
+  entries_context->enumerated_entry = nullptr;
+
+  callback.Run(std::move(entries_context), CACHE_STORAGE_OK);
+}
+
+void CacheStorageCache::OpenEntries(scoped_ptr<ServiceWorkerFetchRequest> request,
+                                    const CacheStorageCacheQueryParams& options,
+                                    const OpenAllEntriesCallback& callback) {
+  scoped_ptr<OpenAllEntriesContext> entries_context(new OpenAllEntriesContext);
+
+
+  int rv;
+  if (request->url.is_empty() || options.ignore_search) {
+    entries_context->backend_iterator = backend_->CreateIterator();
+    disk_cache::Backend::Iterator& iterator = *entries_context->backend_iterator;
+    disk_cache::Entry** enumerated_entry = &entries_context->enumerated_entry;
+
+    net::CompletionCallback open_entry_callback = base::Bind(
+        &CacheStorageCache::DidOpenNextEntry, weak_ptr_factory_.GetWeakPtr(),
+        /*base::Passed(std::move(request)), options,*/ base::Passed(std::move(entries_context)), callback);
+
+    rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
+    if (rv != net::ERR_IO_PENDING)
+      open_entry_callback.Run(rv);
+  } else {
+    disk_cache::Entry** entry_ptr = &entries_context->enumerated_entry;
+
+    net::CompletionCallback open_entry_callback = base::Bind(
+        &CacheStorageCache::DidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
+        /*base::Passed(std::move(request)), options,*/ base::Passed(std::move(entries_context)), callback);
+
+    rv = backend_->OpenEntry(request->url.spec(), entry_ptr, open_entry_callback);
+    if (rv != net::ERR_IO_PENDING)
+      open_entry_callback.Run(rv);
+  }
+}
+
 void CacheStorageCache::OpenAllEntries(const OpenAllEntriesCallback& callback) {
   scoped_ptr<OpenAllEntriesContext> entries_context(new OpenAllEntriesContext);
   entries_context->backend_iterator = backend_->CreateIterator();
@@ -1049,6 +1118,12 @@ void CacheStorageCache::DeleteImpl(
     return;
   }
 
+  ServiceWorkerFetchRequest* r = new ServiceWorkerFetchRequest(*request);
+  OpenEntries(scoped_ptr<ServiceWorkerFetchRequest>(r), match_params, base::Bind(&CacheStorageCache::DeleteDidOpenAllEntries,
+                              weak_ptr_factory_.GetWeakPtr(),
+                              base::Passed(std::move(request)), callback));
+/*
+
   if (match_params.ignore_search) {
     OpenAllEntries(base::Bind(&CacheStorageCache::DeleteDidOpenAllEntries,
                               weak_ptr_factory_.GetWeakPtr(),
@@ -1056,23 +1131,21 @@ void CacheStorageCache::DeleteImpl(
     return;
   }
 
-  scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
-
-  disk_cache::Entry** entry_ptr = entry.get();
-
-  ServiceWorkerFetchRequest* request_ptr = request.get();
-
-  net::CompletionCallback open_entry_callback = base::Bind(
-      &CacheStorageCache::DeleteDidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
-      origin_, base::Passed(std::move(request)), callback,
-      base::Passed(std::move(entry)));
+  ServiceWorkerFetchRequest* r = new ServiceWorkerFetchRequest(*request);
+  OpenEntry(scoped_ptr<ServiceWorkerFetchRequest>(r), base::Bind(&CacheStorageCache::DeleteDidOpenAllEntries,
+                              weak_ptr_factory_.GetWeakPtr(),
+                              base::Passed(std::move(request)), callback));*/
+}
 
-  int rv = backend_->OpenEntry(request_ptr->url.spec(), entry_ptr,
-                               open_entry_callback);
-  if (rv != net::ERR_IO_PENDING)
-    open_entry_callback.Run(rv);
+void CacheStorageCache::DeleteDidOpenAllEntries2(
+    scoped_ptr<ServiceWorkerFetchRequest> request,
+    const ErrorCallback& callback,
+    scoped_ptr<OpenAllEntriesContext> entries_context,
+    CacheStorageError error) {
+  callback.Run(CACHE_STORAGE_OK);
 }
 
+
 void CacheStorageCache::DeleteDidOpenAllEntries(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ErrorCallback& callback,
@@ -1083,12 +1156,12 @@ void CacheStorageCache::DeleteDidOpenAllEntries(
     return;
   }
 
-  GURL request_url_without_query = RemoveQueryParam(request->url);
-  for (Entries::iterator iter = entries_context->entries.begin();
-       iter != entries_context->entries.end(); iter++) {
-    disk_cache::Entry* entry(*iter);
-    if (request_url_without_query == RemoveQueryParam(GURL(entry->GetKey())))
-      entry->Doom();
+  if (request) {
+    GURL request_url_without_query = RemoveQueryParam(request->url);
+    for (size_t i = 0, max = entries_context->entries.size(); i < max; ++i) {
+      if (request_url_without_query == RemoveQueryParam(GURL(entries_context->entries[i]->GetKey())))
+        entries_context->entries[i]->Doom();
+    }
   }
 
   entries_context.reset();