[CacheStorage] Use appopriate type parameters for WebCallbacks (1/3).

This series of CLs fixes WebCallback parameter types used in CacheStorage.

 - WebServiceWorkerResponse* (ownership not transferred)
  => const WebServiceWorkerResponse&
 - WebVector<WebServiceWorkerResponse>* (ownership not transferred)
  => const WebVector<WebServiceWorkerResponse>&
 - WebVector<WebServiceWorkerRequest>* (ownership not transferred)
  => const WebVector<WebServiceWorkerRequest>&
 - WebServiceWorkerCache* (ownership transferred)
  => WebPassOwnPtr<WebServiceWorkerCache>
 - WebVector<WebString>* (ownership not transferred)
  => const WebVector<WebString>&
 - WebServiceWorkerCacheError* (ownership transferred)
  => WebServiceWorkerCacheError

1/3: https://codereview.chromium.org/1284173004/
2/3: https://codereview.chromium.org/1284283003/
3/3: https://codereview.chromium.org/1296723005/

BUG=493531

Review URL: https://codereview.chromium.org/1284173004

git-svn-id: svn://svn.chromium.org/blink/trunk@200825 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/modules/cachestorage/Cache.cpp

@@ -34,24 +34,22 @@ public:
     explicit CacheMatchCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
-    void onSuccess(WebServiceWorkerResponse* webResponse) override
+    void onSuccess(const WebServiceWorkerResponse& webResponse) override
     {
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        m_resolver->resolve(Response::create(m_resolver->scriptState()->executionContext(), *webResponse));
+        m_resolver->resolve(Response::create(m_resolver->scriptState()->executionContext(), webResponse));
         m_resolver.clear();
     }
 
-    // Ownership of |rawReason| must be passed.
-    void onError(WebServiceWorkerCacheError* rawReason) override
+    void onError(WebServiceWorkerCacheError reason) override
     {
-        OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        if (*reason == WebServiceWorkerCacheErrorNotFound)
+        if (reason == WebServiceWorkerCacheErrorNotFound)
             m_resolver->resolve();
         else
-            m_resolver->reject(CacheStorageError::createException(*reason));
+            m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 
@@ -66,24 +64,22 @@ public:
     explicit CacheWithResponsesCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
-    void onSuccess(WebVector<WebServiceWorkerResponse>* webResponses) override
+    void onSuccess(const WebVector<WebServiceWorkerResponse>& webResponses) override
     {
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         HeapVector<Member<Response>> responses;
-        for (size_t i = 0; i < webResponses->size(); ++i)
-            responses.append(Response::create(m_resolver->scriptState()->executionContext(), (*webResponses)[i]));
+        for (size_t i = 0; i < webResponses.size(); ++i)
+            responses.append(Response::create(m_resolver->scriptState()->executionContext(), webResponses[i]));
         m_resolver->resolve(responses);
         m_resolver.clear();
     }
 
-    // Ownership of |rawReason| must be passed.
-    void onError(WebServiceWorkerCacheError* rawReason) override
+    void onError(WebServiceWorkerCacheError reason) override
     {
-        OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        m_resolver->reject(CacheStorageError::createException(*reason));
+        m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 
@@ -128,24 +124,22 @@ public:
     explicit CacheWithRequestsCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
-    void onSuccess(WebVector<WebServiceWorkerRequest>* webRequests) override
+    void onSuccess(const WebVector<WebServiceWorkerRequest>& webRequests) override
     {
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         HeapVector<Member<Request>> requests;
-        for (size_t i = 0; i < webRequests->size(); ++i)
-            requests.append(Request::create(m_resolver->scriptState()->executionContext(), (*webRequests)[i]));
+        for (size_t i = 0; i < webRequests.size(); ++i)
+            requests.append(Request::create(m_resolver->scriptState()->executionContext(), webRequests[i]));
         m_resolver->resolve(requests);
         m_resolver.clear();
     }
 
-    // Ownership of |rawReason| must be passed.
-    void onError(WebServiceWorkerCacheError* rawReason) override
+    void onError(WebServiceWorkerCacheError reason) override
     {
-        OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        m_resolver->reject(CacheStorageError::createException(*reason));
+        m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 

third_party/WebKit/Source/modules/cachestorage/CacheStorage.cpp

@@ -57,16 +57,14 @@ public:
         m_resolver.clear();
     }
 
-    // Ownership of |rawReason| must be passed.
-    void onError(WebServiceWorkerCacheError* rawReason) override
+    void onError(WebServiceWorkerCacheError reason) override
     {
-        OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        if (*reason == WebServiceWorkerCacheErrorNotFound)
+        if (reason == WebServiceWorkerCacheErrorNotFound)
             m_resolver->resolve(false);
         else
-            m_resolver->reject(CacheStorageError::createException(*reason));
+            m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 
@@ -82,33 +80,24 @@ public:
         : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resolver) { }
     ~WithCacheCallbacks() override { }
 
-    // Ownership of |rawWebCache| must be passed.
-    void onSuccess(WebServiceWorkerCache* rawWebCache) override
+    void onSuccess(WebPassOwnPtr<WebServiceWorkerCache> webCache) override
     {
-        OwnPtr<WebServiceWorkerCache> webCache = adoptPtr(rawWebCache);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        // FIXME: Remove this once content's WebServiceWorkerCache implementation has landed.
-        if (!webCache) {
-            m_resolver->reject("not implemented");
-            return;
-        }
         Cache* cache = Cache::create(m_cacheStorage->m_scopedFetcher, webCache.release());
         m_cacheStorage->m_nameToCacheMap.set(m_cacheName, cache);
         m_resolver->resolve(cache);
         m_resolver.clear();
     }
 
-    // Ownership of |rawReason| must be passed.
-    void onError(WebServiceWorkerCacheError* rawReason) override
+    void onError(WebServiceWorkerCacheError reason) override
     {
-        OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        if (*reason == WebServiceWorkerCacheErrorNotFound)
+        if (reason == WebServiceWorkerCacheErrorNotFound)
             m_resolver->resolve();
         else
-            m_resolver->reject(CacheStorageError::createException(*reason));
+            m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 
@@ -125,24 +114,22 @@ public:
     explicit MatchCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
-    void onSuccess(WebServiceWorkerResponse* webResponse) override
+    void onSuccess(const WebServiceWorkerResponse& webResponse) override
     {
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        m_resolver->resolve(Response::create(m_resolver->scriptState()->executionContext(), *webResponse));
+        m_resolver->resolve(Response::create(m_resolver->scriptState()->executionContext(), webResponse));
         m_resolver.clear();
     }
 
-    // Ownership of |rawReason| must be passed.
-    void onError(WebServiceWorkerCacheError* rawReason) override
+    void onError(WebServiceWorkerCacheError reason) override
     {
-        OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        if (*reason == WebServiceWorkerCacheErrorNotFound)
+        if (reason == WebServiceWorkerCacheErrorNotFound)
             m_resolver->resolve();
         else
-            m_resolver->reject(CacheStorageError::createException(*reason));
+            m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 
@@ -168,16 +155,14 @@ public:
         m_resolver.clear();
     }
 
-    // Ownership of |rawReason| must be passed.
-    void onError(WebServiceWorkerCacheError* rawReason) override
+    void onError(WebServiceWorkerCacheError reason) override
     {
-        OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        if (*reason == WebServiceWorkerCacheErrorNotFound)
+        if (reason == WebServiceWorkerCacheErrorNotFound)
             m_resolver->resolve(false);
         else
-            m_resolver->reject(CacheStorageError::createException(*reason));
+            m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 
@@ -195,24 +180,22 @@ public:
         : m_resolver(resolver) { }
     ~KeysCallbacks() override { }
 
-    void onSuccess(WebVector<WebString>* keys) override
+    void onSuccess(const WebVector<WebString>& keys) override
     {
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         Vector<String> wtfKeys;
-        for (size_t i = 0; i < keys->size(); ++i)
-            wtfKeys.append((*keys)[i]);
+        for (size_t i = 0; i < keys.size(); ++i)
+            wtfKeys.append(keys[i]);
         m_resolver->resolve(wtfKeys);
         m_resolver.clear();
     }
 
-    // Ownership of |rawReason| must be passed.
-    void onError(WebServiceWorkerCacheError* rawReason) override
+    void onError(WebServiceWorkerCacheError reason) override
     {
-        OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
-        m_resolver->reject(CacheStorageError::createException(*reason));
+        m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 

third_party/WebKit/Source/modules/cachestorage/CacheTest.cpp

@@ -112,7 +112,7 @@ public:
         checkQueryParamsIfProvided(queryParams);
 
         OwnPtr<CacheMatchCallbacks> ownedCallbacks(adoptPtr(callbacks));
-        return callbacks->onError(new WebServiceWorkerCacheError(m_error));
+        return callbacks->onError(m_error);
     }
 
     void dispatchMatchAll(CacheWithResponsesCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
@@ -122,7 +122,7 @@ public:
         checkQueryParamsIfProvided(queryParams);
 
         OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
-        return callbacks->onError(new WebServiceWorkerCacheError(m_error));
+        return callbacks->onError(m_error);
     }
 
     void dispatchKeys(CacheWithRequestsCallbacks* callbacks, const WebServiceWorkerRequest* webRequest, const QueryParams& queryParams) override
@@ -134,7 +134,7 @@ public:
         }
 
         OwnPtr<CacheWithRequestsCallbacks> ownedCallbacks(adoptPtr(callbacks));
-        return callbacks->onError(new WebServiceWorkerCacheError(m_error));
+        return callbacks->onError(m_error);
     }
 
     void dispatchBatch(CacheBatchCallbacks* callbacks, const WebVector<BatchOperation>& batchOperations) override
@@ -474,7 +474,7 @@ public:
     void dispatchMatch(CacheMatchCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
     {
         OwnPtr<CacheMatchCallbacks> ownedCallbacks(adoptPtr(callbacks));
-        return callbacks->onSuccess(&m_response);
+        return callbacks->onSuccess(m_response);
     }
 
 private:
@@ -510,7 +510,7 @@ public:
     void dispatchKeys(CacheWithRequestsCallbacks* callbacks, const WebServiceWorkerRequest* webRequest, const QueryParams& queryParams) override
     {
         OwnPtr<CacheWithRequestsCallbacks> ownedCallbacks(adoptPtr(callbacks));
-        return callbacks->onSuccess(&m_requests);
+        return callbacks->onSuccess(m_requests);
     }
 
 private:
@@ -555,7 +555,7 @@ public:
     void dispatchMatchAll(CacheWithResponsesCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
     {
         OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
-        return callbacks->onSuccess(&m_responses);
+        return callbacks->onSuccess(m_responses);
     }
 
     void dispatchBatch(CacheBatchCallbacks* callbacks, const WebVector<BatchOperation>& batchOperations) override

third_party/WebKit/Source/modules/cachestorage/InspectorCacheStorageAgent.cpp

@@ -122,11 +122,11 @@ public:
 
     ~RequestCacheNames() override { }
 
-    void onSuccess(WebVector<WebString>* caches)
+    void onSuccess(const WebVector<WebString>& caches) override
     {
         RefPtr<Array<Cache>> array = Array<Cache>::create();
-        for (size_t i = 0; i < caches->size(); i++) {
-            String name = String((*caches)[i]);
+        for (size_t i = 0; i < caches.size(); i++) {
+            String name = String(caches[i]);
             RefPtr<Cache> entry = Cache::create()
                 .setSecurityOrigin(m_securityOrigin)
                 .setCacheName(name)
@@ -136,9 +136,9 @@ public:
         m_callback->sendSuccess(array);
     }
 
-    void onError(WebServiceWorkerCacheError* error)
+    void onError(WebServiceWorkerCacheError error) override
     {
-        m_callback->sendFailure(String::format("Error requesting cache names: %s", serviceWorkerCacheErrorString(*error).data()));
+        m_callback->sendFailure(String::format("Error requesting cache names: %s", serviceWorkerCacheErrorString(error).data()));
     }
 
 private:
@@ -229,14 +229,14 @@ public:
     }
     ~GetCacheResponsesForRequestData() override { }
 
-    void onSuccess(WebServiceWorkerResponse* response)
+    void onSuccess(const WebServiceWorkerResponse& response) override
     {
-        m_accumulator->addRequestResponsePair(m_request, *response);
+        m_accumulator->addRequestResponsePair(m_request, response);
     }
 
-    void onError(WebServiceWorkerCacheError* error)
+    void onError(WebServiceWorkerCacheError error) override
     {
-        m_callback->sendFailure(String::format("Error requesting responses for cache  %s: %s", m_params.cacheName.utf8().data(), serviceWorkerCacheErrorString(*error).data()));
+        m_callback->sendFailure(String::format("Error requesting responses for cache  %s: %s", m_params.cacheName.utf8().data(), serviceWorkerCacheErrorString(error).data()));
     }
 
 private:
@@ -258,25 +258,26 @@ public:
     }
     ~GetCacheKeysForRequestData() override { }
 
-    void onSuccess(WebVector<WebServiceWorkerRequest>* requests)
+    WebServiceWorkerCache* cache() { return m_cache.get(); }
+    void onSuccess(const WebVector<WebServiceWorkerRequest>& requests) override
     {
-        if (requests->isEmpty()) {
+        if (requests.isEmpty()) {
             RefPtr<Array<DataEntry>> array = Array<DataEntry>::create();
             m_callback->sendSuccess(array, false);
             return;
         }
-        RefPtr<ResponsesAccumulator> accumulator = adoptRef(new ResponsesAccumulator(requests->size(), m_params, m_callback));
+        RefPtr<ResponsesAccumulator> accumulator = adoptRef(new ResponsesAccumulator(requests.size(), m_params, m_callback));
 
-        for (size_t i = 0; i < requests->size(); i++) {
-            const auto& request = (*requests)[i];
+        for (size_t i = 0; i < requests.size(); i++) {
+            const auto& request = requests[i];
             auto* cacheRequest = new GetCacheResponsesForRequestData(m_params, request, accumulator, m_callback);
             m_cache->dispatchMatch(cacheRequest, request, WebServiceWorkerCache::QueryParams());
         }
     }
 
-    void onError(WebServiceWorkerCacheError* error)
+    void onError(WebServiceWorkerCacheError error) override
     {
-        m_callback->sendFailure(String::format("Error requesting requests for cache %s: %s", m_params.cacheName.utf8().data(), serviceWorkerCacheErrorString(*error).data()));
+        m_callback->sendFailure(String::format("Error requesting requests for cache %s: %s", m_params.cacheName.utf8().data(), serviceWorkerCacheErrorString(error).data()));
     }
 
 private:
@@ -297,15 +298,15 @@ public:
     }
     ~GetCacheForRequestData() override { }
 
-    void onSuccess(WebServiceWorkerCache* cache)
+    void onSuccess(WebPassOwnPtr<WebServiceWorkerCache> cache) override
     {
-        auto* cacheRequest = new GetCacheKeysForRequestData(m_params, adoptPtr(cache), m_callback);
-        cache->dispatchKeys(cacheRequest, nullptr, WebServiceWorkerCache::QueryParams());
+        auto* cacheRequest = new GetCacheKeysForRequestData(m_params, cache.release(), m_callback);
+        cacheRequest->cache()->dispatchKeys(cacheRequest, nullptr, WebServiceWorkerCache::QueryParams());
     }
 
-    void onError(WebServiceWorkerCacheError* error)
+    void onError(WebServiceWorkerCacheError error) override
     {
-        m_callback->sendFailure(String::format("Error requesting cache %s: %s", m_params.cacheName.utf8().data(), serviceWorkerCacheErrorString(*error).data()));
+        m_callback->sendFailure(String::format("Error requesting cache %s: %s", m_params.cacheName.utf8().data(), serviceWorkerCacheErrorString(error).data()));
     }
 
 private:
@@ -323,14 +324,14 @@ public:
     }
     ~DeleteCache() override { }
 
-    void onSuccess()
+    void onSuccess() override
     {
         m_callback->sendSuccess();
     }
 
-    void onError(WebServiceWorkerCacheError* error)
+    void onError(WebServiceWorkerCacheError error) override
     {
-        m_callback->sendFailure(String::format("Error requesting cache names: %s", serviceWorkerCacheErrorString(*error).data()));
+        m_callback->sendFailure(String::format("Error requesting cache names: %s", serviceWorkerCacheErrorString(error).data()));
     }
 
 private:
@@ -347,12 +348,12 @@ public:
     }
     ~DeleteCacheEntry() override { }
 
-    void onSuccess()
+    void onSuccess() override
     {
         m_callback->sendSuccess();
     }
 
-    void onError(WebServiceWorkerCacheError error)
+    void onError(WebServiceWorkerCacheError error) override
     {
         m_callback->sendFailure(String::format("Error requesting cache names: %s", serviceWorkerCacheErrorString(error).data()));
     }
@@ -374,20 +375,20 @@ public:
     }
     ~GetCacheForDeleteEntry() override { }
 
-    void onSuccess(WebServiceWorkerCache* cache)
+    void onSuccess(WebPassOwnPtr<WebServiceWorkerCache> cache) override
     {
-        auto* deleteRequest = new DeleteCacheEntry( m_callback);
+        auto* deleteRequest = new DeleteCacheEntry(m_callback);
         BatchOperation deleteOperation;
         deleteOperation.operationType = WebServiceWorkerCache::OperationTypeDelete;
         deleteOperation.request.setURL(KURL(ParsedURLString, m_requestSpec));
         Vector<BatchOperation> operations;
         operations.append(deleteOperation);
-        cache->dispatchBatch(deleteRequest, WebVector<BatchOperation>(operations));
+        cache.release()->dispatchBatch(deleteRequest, WebVector<BatchOperation>(operations));
     }
 
-    void onError(WebServiceWorkerCacheError* error)
+    void onError(WebServiceWorkerCacheError error) override
     {
-        m_callback->sendFailure(String::format("Error requesting cache %s: %s", m_cacheName.utf8().data(), serviceWorkerCacheErrorString(*error).data()));
+        m_callback->sendFailure(String::format("Error requesting cache %s: %s", m_cacheName.utf8().data(), serviceWorkerCacheErrorString(error).data()));
     }
 
 private:

third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerCache.h

@@ -20,9 +20,39 @@ namespace blink {
 // This object is owned by Blink, and should be destroyed as each Cache instance is no longer in use.
 class WebServiceWorkerCache {
 public:
-    using CacheMatchCallbacks = WebCallbacks<WebServiceWorkerResponse*, WebServiceWorkerCacheError*>;
-    using CacheWithResponsesCallbacks = WebCallbacks<WebVector<WebServiceWorkerResponse>*, WebServiceWorkerCacheError*>;
-    using CacheWithRequestsCallbacks = WebCallbacks<WebVector<WebServiceWorkerRequest>*, WebServiceWorkerCacheError*>;
+    class CacheMatchCallbacks : public WebCallbacks<const WebServiceWorkerResponse&, WebServiceWorkerCacheError> {
+    public:
+        void onSuccess(WebServiceWorkerResponse* r) { onSuccess(*r); }
+        void onError(WebServiceWorkerCacheError* e)
+        {
+            onError(*e);
+            delete e;
+        }
+        void onSuccess(const WebServiceWorkerResponse&) override {}
+        void onError(WebServiceWorkerCacheError) override {}
+    };
+    class CacheWithResponsesCallbacks : public WebCallbacks<const WebVector<WebServiceWorkerResponse>&, WebServiceWorkerCacheError> {
+    public:
+        void onSuccess(WebVector<WebServiceWorkerResponse>* r) { onSuccess(*r); }
+        void onError(WebServiceWorkerCacheError* e)
+        {
+            onError(*e);
+            delete e;
+        }
+        void onSuccess(const WebVector<WebServiceWorkerResponse>&) override {}
+        void onError(WebServiceWorkerCacheError) override {}
+    };
+    class CacheWithRequestsCallbacks : public WebCallbacks<const WebVector<WebServiceWorkerRequest>&, WebServiceWorkerCacheError> {
+    public:
+        void onSuccess(WebVector<WebServiceWorkerRequest>* r) { onSuccess(*r); }
+        void onError(WebServiceWorkerCacheError* e)
+        {
+            onError(*e);
+            delete e;
+        }
+        void onSuccess(const WebVector<WebServiceWorkerRequest>&) override {}
+        void onError(WebServiceWorkerCacheError) override {}
+    };
     using CacheBatchCallbacks = WebCallbacks<void, WebServiceWorkerCacheError>;
 
     virtual ~WebServiceWorkerCache() { }

third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerCacheStorage.h

@@ -7,6 +7,7 @@
 
 #include "public/platform/WebCallbacks.h"
 #include "public/platform/WebCommon.h"
+#include "public/platform/WebPassOwnPtr.h"
 #include "public/platform/WebServiceWorkerCache.h"
 #include "public/platform/WebServiceWorkerCacheError.h"
 #include "public/platform/WebString.h"
@@ -21,10 +22,51 @@ class WebServiceWorkerCache;
 // after operations complete.
 class WebServiceWorkerCacheStorage {
 public:
-    typedef WebCallbacks<void, WebServiceWorkerCacheError*> CacheStorageCallbacks;
-    typedef WebCallbacks<WebServiceWorkerCache*, WebServiceWorkerCacheError*> CacheStorageWithCacheCallbacks;
-    typedef WebCallbacks<WebVector<WebString>*, WebServiceWorkerCacheError*> CacheStorageKeysCallbacks;
-    typedef WebCallbacks<WebServiceWorkerResponse*, WebServiceWorkerCacheError*> CacheStorageMatchCallbacks;
+    class CacheStorageCallbacks : public WebCallbacks<void, WebServiceWorkerCacheError> {
+    public:
+        void onError(WebServiceWorkerCacheError* e)
+        {
+            onError(*e);
+            delete e;
+        }
+        void onError(WebServiceWorkerCacheError) override {}
+    };
+    class CacheStorageWithCacheCallbacks : public WebCallbacks<WebPassOwnPtr<WebServiceWorkerCache>, WebServiceWorkerCacheError> {
+    public:
+        void onSuccess(WebServiceWorkerCache* r)
+        {
+            onSuccess(adoptWebPtr(r));
+        }
+        void onError(WebServiceWorkerCacheError* e)
+        {
+            onError(*e);
+            delete e;
+        }
+        void onSuccess(WebPassOwnPtr<WebServiceWorkerCache>) override {}
+        void onError(WebServiceWorkerCacheError) override {}
+    };
+    class CacheStorageKeysCallbacks : public WebCallbacks<const WebVector<WebString>&, WebServiceWorkerCacheError> {
+    public:
+        void onSuccess(WebVector<WebString>* r) { onSuccess(*r); }
+        void onError(WebServiceWorkerCacheError* e)
+        {
+            onError(*e);
+            delete e;
+        }
+        void onSuccess(const WebVector<WebString>&) override {}
+        void onError(WebServiceWorkerCacheError) override {}
+    };
+    class CacheStorageMatchCallbacks : public WebCallbacks<const WebServiceWorkerResponse&, WebServiceWorkerCacheError> {
+    public:
+        void onSuccess(WebServiceWorkerResponse* r) { onSuccess(*r); }
+        void onError(WebServiceWorkerCacheError* e)
+        {
+            onError(*e);
+            delete e;
+        }
+        void onSuccess(const WebServiceWorkerResponse&) override {}
+        void onError(WebServiceWorkerCacheError) override {}
+    };
 
     virtual ~WebServiceWorkerCacheStorage() { }