CacheStorage: Expand cache.keys() method.

content/browser/cache_storage/cache_storage_cache.h

 // 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.
 
 #ifndef CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_H_
 #define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_H_
 
 #include <stdint.h>
 
 #include <vector>
@@ skipping 84 matching lines @@
   //
   // TODO(nhiroki): This function should run all operations atomically.
   // http://crbug.com/486637
   void BatchOperation(const std::vector<CacheStorageBatchOperation>& operations,
                       const ErrorCallback& callback);
   void BatchDidOneOperation(const base::Closure& barrier_closure,
                             ErrorCallback* callback,
                             CacheStorageError error);
   void BatchDidAllOperations(scoped_ptr<ErrorCallback> callback);
 
   // TODO(jkarlin): Have keys take an optional ServiceWorkerFetchRequest.

[zino, 2016/02/24 18:26:57]

jkarlin@,

Are you working on this TODO?
If you are working on the issue, I'm waiting for you.
If not so, can I resolve the issue with this CL together?

   // Returns CACHE_STORAGE_OK and a vector of requests if there are no errors.
-  void Keys(const RequestsCallback& callback);
+  void Keys(scoped_ptr<ServiceWorkerFetchRequest> request,
+            const CacheStorageCacheQueryParams& match_params,
+            const RequestsCallback& callback);
 
   // Closes the backend. Future operations that require the backend
   // will exit early. Close should only be called once per CacheStorageCache.
   void Close(const base::Closure& callback);
 
   // The size of the cache's contents. This runs in parallel with other Cache
   // operations.
   void Size(const SizeCallback& callback);
 
   // Gets the cache's size, closes the backend, and then runs |callback| with
@@ skipping 112 matching lines @@
       const ErrorCallback& callback,
       scoped_ptr<OpenAllEntriesContext> entries_context,
       CacheStorageError error);
   void DeleteDidOpenEntry(const GURL& origin,
                           scoped_ptr<ServiceWorkerFetchRequest> request,
                           const CacheStorageCache::ErrorCallback& callback,
                           scoped_ptr<disk_cache::Entry*> entryptr,
                           int rv);
 
   // Keys callbacks.
-  void KeysImpl(const RequestsCallback& callback);
-  void KeysDidOpenAllEntries(const RequestsCallback& callback,
+  void KeysImpl(scoped_ptr<KeysContext> keys_context);
+  void KeysDidOpenAllEntries(scoped_ptr<KeysContext> keys_context,
                              scoped_ptr<OpenAllEntriesContext> entries_context,
                              CacheStorageError error);
   void KeysProcessNextEntry(scoped_ptr<KeysContext> keys_context,
                             const Entries::iterator& iter);
   void KeysDidReadMetadata(scoped_ptr<KeysContext> keys_context,
                            const Entries::iterator& iter,
                            scoped_ptr<CacheMetadata> metadata);
 
   void CloseImpl(const base::Closure& callback);
 
@@ skipping 56 matching lines @@
   bool memory_only_;
 
   base::WeakPtrFactory<CacheStorageCache> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorageCache);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_H_