content/browser/cache_storage/cache_storage_cache.h - Issue 2947753002: CacheStorage: Migrate to BindOnce/OnceCallback/OnceClosure

Unified Diff: content/browser/cache_storage/cache_storage_cache.h

Issue 2947753002: CacheStorage: Migrate to BindOnce/OnceCallback/OnceClosure (Closed)

Patch Set: Created 3 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« content/browser/cache_storage/cache_storage.cc ('K') | « content/browser/cache_storage/cache_storage_blob_to_disk_cache_unittest.cc ('k') | content/browser/cache_storage/cache_storage_cache.cc » ('j') | content/browser/cache_storage/cache_storage_cache.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: content/browser/cache_storage/cache_storage_cache.h

diff --git a/content/browser/cache_storage/cache_storage_cache.h b/content/browser/cache_storage/cache_storage_cache.h

index 1afe338c2ac94353655b9a9712ce3f4721a8c6bf..a40a769f4bbb8edb9e658cf2a140ed74de1eeed7 100644

--- a/content/browser/cache_storage/cache_storage_cache.h

+++ b/content/browser/cache_storage/cache_storage_cache.h

@@ -50,21 +50,21 @@ class CacheMetadata;

// will be called so long as the cache object lives.

class CONTENT_EXPORT CacheStorageCache {

public:

- using ErrorCallback = base::Callback<void(CacheStorageError)>;

+ using ErrorCallback = base::OnceCallback<void(CacheStorageError)>;

using ResponseCallback =

- base::Callback<void(CacheStorageError,

- std::unique_ptr<ServiceWorkerResponse>,

- std::unique_ptr<storage::BlobDataHandle>)>;

+ base::OnceCallback<void(CacheStorageError,

+ std::unique_ptr<ServiceWorkerResponse>,

+ std::unique_ptr<storage::BlobDataHandle>)>;

using Responses = std::vector<ServiceWorkerResponse>;

using BlobDataHandles = std::vector<std::unique_ptr<storage::BlobDataHandle>>;

using ResponsesCallback =

- base::Callback<void(CacheStorageError,

- std::unique_ptr<Responses>,

- std::unique_ptr<BlobDataHandles>)>;

+ base::OnceCallback<void(CacheStorageError,

+ std::unique_ptr<Responses>,

+ std::unique_ptr<BlobDataHandles>)>;

using Requests = std::vector<ServiceWorkerFetchRequest>;

using RequestsCallback =

- base::Callback<void(CacheStorageError, std::unique_ptr<Requests>)>;

- using SizeCallback = base::Callback<void(int64_t)>;

+ base::OnceCallback<void(CacheStorageError, std::unique_ptr<Requests>)>;

+ using SizeCallback = base::OnceCallback<void(int64_t)>;

enum EntryIndex { INDEX_HEADERS = 0, INDEX_RESPONSE_BODY, INDEX_SIDE_DATA };

@@ -88,13 +88,13 @@ class CONTENT_EXPORT CacheStorageCache {

// Returns ERROR_TYPE_NOT_FOUND if not found.

void Match(std::unique_ptr<ServiceWorkerFetchRequest> request,

const CacheStorageCacheQueryParams& match_params,

- const ResponseCallback& callback);

+ 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(std::unique_ptr<ServiceWorkerFetchRequest> request,

const CacheStorageCacheQueryParams& match_params,

- const ResponsesCallback& callback);

+ ResponsesCallback callback);

// Writes the side data (ex: V8 code cache) for the specified cache entry.

// If it doesn't exist, or the |expected_response_time| differs from the

@@ -102,7 +102,7 @@ class CONTENT_EXPORT CacheStorageCache {

// Note: This "side data" is same meaning as "metadata" in HTTPCache. We use

// "metadata" in cache_storage.proto for the pair of headers of a request and

// a response. To avoid the confusion we use "side data" here.

- void WriteSideData(const CacheStorageCache::ErrorCallback& callback,

+ void WriteSideData(CacheStorageCache::ErrorCallback callback,

const GURL& url,

base::Time expected_response_time,

scoped_refptr<net::IOBuffer> buffer,

@@ -122,34 +122,37 @@ class CONTENT_EXPORT CacheStorageCache {

// TODO(nhiroki): This function should run all operations atomically.

// http://crbug.com/486637

void BatchOperation(const std::vector<CacheStorageBatchOperation>& operations,

- const ErrorCallback& callback);

+ ErrorCallback callback);

void BatchDidGetUsageAndQuota(

const std::vector<CacheStorageBatchOperation>& operations,

- const ErrorCallback& callback,

+ ErrorCallback callback,

int64_t space_required,

storage::QuotaStatusCode status_code,

int64_t usage,

int64_t quota);

- void BatchDidOneOperation(const base::Closure& barrier_closure,

- ErrorCallback* callback,

- CacheStorageError error);

- void BatchDidAllOperations(std::unique_ptr<ErrorCallback> callback);

+ void BatchDidOneOperation(

+ const base::RepeatingClosure& barrier_closure,

+ base::RepeatingCallback<void(CacheStorageError)>* callback,

+ CacheStorageError error);

+ void BatchDidAllOperations(

+ std::unique_ptr<base::RepeatingCallback<void(CacheStorageError)>>

+ callback);

// Returns CACHE_STORAGE_OK and a vector of requests if there are no errors.

void Keys(std::unique_ptr<ServiceWorkerFetchRequest> request,

const CacheStorageCacheQueryParams& options,

- const RequestsCallback& callback);

+ 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);

+ void Close(base::OnceClosure callback);

// The size of the cache's contents.

- void Size(const SizeCallback& callback);

+ void Size(SizeCallback callback);

// Gets the cache's size, closes the backend, and then runs |callback| with

// the cache's size.

- void GetSizeThenClose(const SizeCallback& callback);

+ void GetSizeThenClose(SizeCallback callback);

// Async operations in progress will cancel and not run their callbacks.

virtual ~CacheStorageCache();

@@ -182,22 +185,18 @@ class CONTENT_EXPORT CacheStorageCache {

friend class TestCacheStorageCache;

friend class CacheStorageCacheTest;

- struct OpenAllEntriesContext;

struct PutContext;

struct QueryCacheContext;

struct QueryCacheResult;

using QueryCacheResults = std::vector<QueryCacheResult>;

using QueryCacheCallback =

- base::Callback<void(CacheStorageError,

- std::unique_ptr<QueryCacheResults>)>;

+ base::OnceCallback<void(CacheStorageError,

+ std::unique_ptr<QueryCacheResults>)>;

using Entries = std::vector<disk_cache::Entry*>;

using ScopedBackendPtr = std::unique_ptr<disk_cache::Backend>;

using BlobToDiskCacheIDMap =

IDMap<std::unique_ptr<CacheStorageBlobToDiskCache>>;

- using OpenAllEntriesCallback =

- base::Callback<void(std::unique_ptr<OpenAllEntriesContext>,

- CacheStorageError)>;

CacheStorageCache(

const GURL& origin,

@@ -209,12 +208,6 @@ class CONTENT_EXPORT CacheStorageCache {

base::WeakPtr<storage::BlobStorageContext> blob_context,

int64_t cache_size);

- // Returns all entries in this cache.

jsbell 2017/06/19 23:45:00 This appeared to be dead code - there are no imple

- void OpenAllEntries(const OpenAllEntriesCallback& callback);

- void DidOpenNextEntry(std::unique_ptr<OpenAllEntriesContext> entries_context,

- const OpenAllEntriesCallback& callback,

- int rv);

// Runs |callback| with matching requests/response data. The data provided

// in the QueryCacheResults depends on the |query_type|. If |query_type| is

// CACHE_ENTRIES then only out_entries is valid. If |query_type| is REQUESTS

@@ -224,7 +217,7 @@ class CONTENT_EXPORT CacheStorageCache {

void QueryCache(std::unique_ptr<ServiceWorkerFetchRequest> request,

const CacheStorageCacheQueryParams& options,

QueryCacheType query_type,

- const QueryCacheCallback& callback);

+ QueryCacheCallback callback);

void QueryCacheDidOpenFastPath(

std::unique_ptr<QueryCacheContext> query_cache_context,

int rv);

@@ -243,8 +236,8 @@ class CONTENT_EXPORT CacheStorageCache {

// Match callbacks

void MatchImpl(std::unique_ptr<ServiceWorkerFetchRequest> request,

const CacheStorageCacheQueryParams& match_params,

- const ResponseCallback& callback);

- void MatchDidMatchAll(const ResponseCallback& callback,

+ ResponseCallback callback);

+ void MatchDidMatchAll(ResponseCallback callback,

CacheStorageError match_all_error,

std::unique_ptr<Responses> match_all_responses,

std::unique_ptr<BlobDataHandles> match_all_handles);

@@ -252,14 +245,14 @@ class CONTENT_EXPORT CacheStorageCache {

// MatchAll callbacks

void MatchAllImpl(std::unique_ptr<ServiceWorkerFetchRequest> request,

const CacheStorageCacheQueryParams& options,

- const ResponsesCallback& callback);

+ ResponsesCallback callback);

void MatchAllDidQueryCache(

- const ResponsesCallback& callback,

+ ResponsesCallback callback,

CacheStorageError error,

std::unique_ptr<QueryCacheResults> query_cache_results);

// WriteSideData callbacks

- void WriteSideDataDidGetQuota(const ErrorCallback& callback,

+ void WriteSideDataDidGetQuota(ErrorCallback callback,

const GURL& url,

base::Time expected_response_time,

scoped_refptr<net::IOBuffer> buffer,

@@ -268,12 +261,12 @@ class CONTENT_EXPORT CacheStorageCache {

int64_t usage,

int64_t quota);

- void WriteSideDataImpl(const ErrorCallback& callback,

+ void WriteSideDataImpl(ErrorCallback callback,

const GURL& url,

base::Time expected_response_time,

scoped_refptr<net::IOBuffer> buffer,

int buf_len);

- void WriteSideDataDidGetUsageAndQuota(const ErrorCallback& callback,

+ void WriteSideDataDidGetUsageAndQuota(ErrorCallback callback,

const GURL& url,

base::Time expected_response_time,

scoped_refptr<net::IOBuffer> buffer,

@@ -281,20 +274,20 @@ class CONTENT_EXPORT CacheStorageCache {

storage::QuotaStatusCode status_code,

int64_t usage,

int64_t quota);

- void WriteSideDataDidOpenEntry(const ErrorCallback& callback,

+ void WriteSideDataDidOpenEntry(ErrorCallback callback,

base::Time expected_response_time,

scoped_refptr<net::IOBuffer> buffer,

int buf_len,

std::unique_ptr<disk_cache::Entry*> entry_ptr,

int rv);

void WriteSideDataDidReadMetaData(

- const ErrorCallback& callback,

+ ErrorCallback callback,

base::Time expected_response_time,

scoped_refptr<net::IOBuffer> buffer,

int buf_len,

disk_cache::ScopedEntryPtr entry,

std::unique_ptr<proto::CacheMetadata> headers);

- void WriteSideDataDidWrite(const ErrorCallback& callback,

+ void WriteSideDataDidWrite(ErrorCallback callback,

disk_cache::ScopedEntryPtr entry,

int expected_bytes,

int rv);

@@ -302,8 +295,7 @@ class CONTENT_EXPORT CacheStorageCache {

// Puts the request and response object in the cache. The response body (if

// present) is stored in the cache, but not the request body. Returns OK on

// success.

- void Put(const CacheStorageBatchOperation& operation,

- const ErrorCallback& callback);

+ void Put(const CacheStorageBatchOperation& operation, ErrorCallback callback);

void PutImpl(std::unique_ptr<PutContext> put_context);

void PutDidDoomEntry(std::unique_ptr<PutContext> put_context, int rv);

void PutDidGetUsageAndQuota(std::unique_ptr<PutContext> put_context,

@@ -324,49 +316,48 @@ class CONTENT_EXPORT CacheStorageCache {

// Asynchronously calculates the current cache size, notifies the quota

// manager of any change from the last report, and sets cache_size_ to the new

// size.

- void UpdateCacheSize(const base::Closure& callback);

+ void UpdateCacheSize(base::OnceClosure callback);

void UpdateCacheSizeGotSize(std::unique_ptr<CacheStorageCacheHandle>,

- const base::Closure& callback,

+ base::OnceClosure callback,

int current_cache_size);

// Returns ERROR_NOT_FOUND if not found. Otherwise deletes and returns OK.

void Delete(const CacheStorageBatchOperation& operation,

- const ErrorCallback& callback);

+ ErrorCallback callback);

void DeleteImpl(std::unique_ptr<ServiceWorkerFetchRequest> request,

const CacheStorageCacheQueryParams& match_params,

- const ErrorCallback& callback);

+ ErrorCallback callback);

void DeleteDidQueryCache(

- const ErrorCallback& callback,

+ ErrorCallback callback,

CacheStorageError error,

std::unique_ptr<QueryCacheResults> query_cache_results);

// Keys callbacks.

void KeysImpl(std::unique_ptr<ServiceWorkerFetchRequest> request,

const CacheStorageCacheQueryParams& options,

- const RequestsCallback& callback);

+ RequestsCallback callback);

void KeysDidQueryCache(

- const RequestsCallback& callback,

+ RequestsCallback callback,

CacheStorageError error,

std::unique_ptr<QueryCacheResults> query_cache_results);

- void CloseImpl(const base::Closure& callback);

+ void CloseImpl(base::OnceClosure callback);

- void SizeImpl(const SizeCallback& callback);

+ void SizeImpl(SizeCallback callback);

- void GetSizeThenCloseDidGetSize(const SizeCallback& callback,

- int64_t cache_size);

+ void GetSizeThenCloseDidGetSize(SizeCallback callback, int64_t cache_size);

// Loads the backend and calls the callback with the result (true for

// success). The callback will always be called. Virtual for tests.

- virtual void CreateBackend(const ErrorCallback& callback);

- void CreateBackendDidCreate(const CacheStorageCache::ErrorCallback& callback,

+ virtual void CreateBackend(ErrorCallback callback);

+ void CreateBackendDidCreate(ErrorCallback callback,

std::unique_ptr<ScopedBackendPtr> backend_ptr,

int rv);

void InitBackend();

- void InitDidCreateBackend(const base::Closure& callback,

+ void InitDidCreateBackend(base::OnceClosure callback,

CacheStorageError cache_create_error);

- void InitGotCacheSize(const base::Closure& callback,

+ void InitGotCacheSize(base::OnceClosure callback,

CacheStorageError cache_create_error,

int cache_size);