test

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 54 matching lines @@
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
   static scoped_refptr<CacheStorageCache> CreatePersistentCache(
       const GURL& origin,
       const base::FilePath& path,
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
 
+  void QueryCache(scoped_ptr<ServiceWorkerFetchRequest> request,
+                  const CacheStorageCacheQueryParams& options);
+
   // Returns ERROR_TYPE_NOT_FOUND if not found.
   void Match(scoped_ptr<ServiceWorkerFetchRequest> request,
              const ResponseCallback& callback);
 
   // Returns CACHE_STORAGE_OK and matched responses in this cache. If there are
   // no responses, returns CACHE_STORAGE_OK and an empty vector.
   void MatchAll(scoped_ptr<ServiceWorkerFetchRequest> request,
                 const CacheStorageCacheQueryParams& match_params,
                 const ResponsesCallback& callback);
 
@@ skipping 69 matching lines @@
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
 
   // Async operations in progress will cancel and not run their callbacks.
   virtual ~CacheStorageCache();
 
   // Returns true if the backend is ready to operate.
   bool LazyInitialize();
 
   // Returns all entries in this cache.
+  void OpenEntries(scoped_ptr<ServiceWorkerFetchRequest> request,
+                                    const CacheStorageCacheQueryParams& options,
+                                    const OpenAllEntriesCallback& callback);
   void OpenAllEntries(const OpenAllEntriesCallback& callback);
   void DidOpenNextEntry(scoped_ptr<OpenAllEntriesContext> entries_context,
                         const OpenAllEntriesCallback& callback,
                         int rv);
+  void OpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
+                 const OpenAllEntriesCallback& callback);
+  void DidOpenEntry(scoped_ptr<OpenAllEntriesContext> entries_context,
+                    const OpenAllEntriesCallback& callback,
+                    int rv);
 
   // Match callbacks
   void MatchImpl(scoped_ptr<ServiceWorkerFetchRequest> request,
                  const ResponseCallback& callback);
   void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                          const ResponseCallback& callback,
                          scoped_ptr<disk_cache::Entry*> entry_ptr,
                          int rv);
   void MatchDidReadMetadata(scoped_ptr<ServiceWorkerFetchRequest> request,
                             const ResponseCallback& callback,
@@ skipping 40 matching lines @@
   // size. Runs |callback| once complete.
   void UpdateCacheSize();
   void UpdateCacheSizeGotSize(int current_cache_size);
 
   // Returns ERROR_NOT_FOUND if not found. Otherwise deletes and returns OK.
   void Delete(const CacheStorageBatchOperation& operation,
               const ErrorCallback& callback);
   void DeleteImpl(scoped_ptr<ServiceWorkerFetchRequest> request,
                   const CacheStorageCacheQueryParams& match_params,
                   const ErrorCallback& callback);
+  void DeleteDidOpenAllEntries2(
+      scoped_ptr<ServiceWorkerFetchRequest> request,
+      const ErrorCallback& callback,
+      scoped_ptr<OpenAllEntriesContext> entries_context,
+      CacheStorageError error);
   void DeleteDidOpenAllEntries(
       scoped_ptr<ServiceWorkerFetchRequest> request,
       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);
@@ skipping 70 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_