Oilpan: fix build after r186900.

Source/modules/serviceworkers/InspectorServiceWorkerCacheAgent.cpp

 // 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.
 
 #include "config.h"
 #include "modules/serviceworkers/InspectorServiceWorkerCacheAgent.h"
 
 #include "core/InspectorBackendDispatcher.h"
 #include "core/InspectorTypeBuilder.h"
 #include "modules/serviceworkers/ServiceWorkerGlobalScope.h"
@@ skipping 61 matching lines @@
         return CString("unknown error.");
         break;
     }
 }
 
 class RequestCacheNames
     : public WebServiceWorkerCacheStorage::CacheStorageKeysCallbacks {
     WTF_MAKE_NONCOPYABLE(RequestCacheNames);
 
 public:
-    RequestCacheNames(PassRefPtr<RequestCacheNamesCallback> callback)
+    RequestCacheNames(PassRefPtrWillBeRawPtr<RequestCacheNamesCallback> callback)
         : m_callback(callback)
     {
     }
 
     virtual ~RequestCacheNames() { }
 
     void onSuccess(WebVector<WebString>* caches)
     {
         RefPtr<TypeBuilder::Array<String>> array = TypeBuilder::Array<String>::create();
         for (size_t i = 0; i < caches->size(); i++) {
             array->addItem(String((*caches)[i]));
         }
         m_callback->sendSuccess(array);
     }
 
     void onError(WebServiceWorkerCacheError* error)
     {
         m_callback->sendFailure(String::format("Error requesting cache names: %s", serviceWorkerCacheErrorString(error).data()));
     }
 
 private:
-    RefPtr<RequestCacheNamesCallback> m_callback;
+    RefPtrWillBePersistent<RequestCacheNamesCallback> m_callback;
 };
 
 struct DataRequestParams {
     String cacheName;
     int skipCount;
     int pageSize;
 };
 
 struct RequestResponse {
     RequestResponse() { }
     RequestResponse(const String& request, const String& response)
         : request(request)
         , response(response)
     {
     }
     String request;
     String response;
 };
 
 class ResponsesAccumulator : public RefCounted<ResponsesAccumulator> {
     WTF_MAKE_NONCOPYABLE(ResponsesAccumulator);
 
 public:
-    ResponsesAccumulator(int numResponses, const DataRequestParams& params, PassRefPtr<RequestEntriesCallback> callback)
+    ResponsesAccumulator(int numResponses, const DataRequestParams& params, PassRefPtrWillBeRawPtr<RequestEntriesCallback> callback)
         : m_params(params)
         , m_numResponsesLeft(numResponses)
         , m_responses(static_cast<size_t>(numResponses))
         , m_callback(callback)
     {
     }
 
     void addRequestResponsePair(const WebServiceWorkerRequest& request, const WebServiceWorkerResponse& response)
     {
         ASSERT(m_numResponsesLeft > 0);
@@ skipping 23 matching lines @@
                 .setResponse(JSONString::create(requestResponse.response)->toJSONString());
             array->addItem(entry);
         }
         m_callback->sendSuccess(array, hasMore);
     }
 
 private:
     DataRequestParams m_params;
     int m_numResponsesLeft;
     Vector<RequestResponse> m_responses;
-    RefPtr<RequestEntriesCallback> m_callback;
+    RefPtrWillBePersistent<RequestEntriesCallback> m_callback;
 };
 
 class GetCacheResponsesForRequestData : public WebServiceWorkerCache::CacheMatchCallbacks {
     WTF_MAKE_NONCOPYABLE(GetCacheResponsesForRequestData);
 
 public:
     GetCacheResponsesForRequestData(
         const DataRequestParams& params, const WebServiceWorkerRequest& request,
-        PassRefPtr<ResponsesAccumulator> accum, PassRefPtr<RequestEntriesCallback> callback)
+        PassRefPtr<ResponsesAccumulator> accum, PassRefPtrWillBeRawPtr<RequestEntriesCallback> callback)
         : m_params(params)
         , m_request(request)
         , m_accumulator(accum)
         , m_callback(callback)
     {
     }
     virtual ~GetCacheResponsesForRequestData() { }
 
     void onSuccess(WebServiceWorkerResponse* response)
     {
         m_accumulator->addRequestResponsePair(m_request, *response);
     }
 
     void onError(WebServiceWorkerCacheError* error)
     {
         m_callback->sendFailure(String::format("Error requesting responses for cache  %s: %s", m_params.cacheName.utf8().data(), serviceWorkerCacheErrorString(error).data()));
     }
 
 private:
     DataRequestParams m_params;
     WebServiceWorkerRequest m_request;
     RefPtr<ResponsesAccumulator> m_accumulator;
-    RefPtr<RequestEntriesCallback> m_callback;
+    RefPtrWillBePersistent<RequestEntriesCallback> m_callback;
 };
 
 class GetCacheKeysForRequestData : public WebServiceWorkerCache::CacheWithRequestsCallbacks {
     WTF_MAKE_NONCOPYABLE(GetCacheKeysForRequestData);
 
 public:
-    GetCacheKeysForRequestData(const DataRequestParams& params, PassOwnPtr<WebServiceWorkerCache> cache, PassRefPtr<RequestEntriesCallback> callback)
+    GetCacheKeysForRequestData(const DataRequestParams& params, PassOwnPtr<WebServiceWorkerCache> cache, PassRefPtrWillBeRawPtr<RequestEntriesCallback> callback)
         : m_params(params)
         , m_cache(cache)
         , m_callback(callback)
     {
     }
     virtual ~GetCacheKeysForRequestData() { }
 
     void onSuccess(WebVector<WebServiceWorkerRequest>* requests)
     {
         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];
             auto* cacheRequest = new GetCacheResponsesForRequestData(m_params, request, accumulator, m_callback);
             m_cache->dispatchMatch(cacheRequest, request, WebServiceWorkerCache::QueryParams());
         }
     }
 
     void onError(WebServiceWorkerCacheError* error)
     {
         m_callback->sendFailure(String::format("Error requesting requests for cache %s: %s", m_params.cacheName.utf8().data(), serviceWorkerCacheErrorString(error).data()));
     }
 
 private:
     DataRequestParams m_params;
     OwnPtr<WebServiceWorkerCache> m_cache;
-    RefPtr<RequestEntriesCallback> m_callback;
+    RefPtrWillBePersistent<RequestEntriesCallback> m_callback;
 };
 
 class GetCacheForRequestData
     : public WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks {
     WTF_MAKE_NONCOPYABLE(GetCacheForRequestData);
 
 public:
-    GetCacheForRequestData(const DataRequestParams& params, PassRefPtr<RequestEntriesCallback> callback)
+    GetCacheForRequestData(const DataRequestParams& params, PassRefPtrWillBeRawPtr<RequestEntriesCallback> callback)
         : m_params(params)
         , m_callback(callback)
     {
     }
     virtual ~GetCacheForRequestData() { }
 
     void onSuccess(WebServiceWorkerCache* cache)
     {
         auto* cacheRequest = new GetCacheKeysForRequestData(m_params, adoptPtr(cache), m_callback);
         cache->dispatchKeys(cacheRequest, nullptr, WebServiceWorkerCache::QueryParams());
     }
 
     void onError(WebServiceWorkerCacheError* error)
     {
         m_callback->sendFailure(String::format("Error requesting cache %s: %s", m_params.cacheName.utf8().data(), serviceWorkerCacheErrorString(error).data()));
     }
 
 private:
     DataRequestParams m_params;
-    RefPtr<RequestEntriesCallback> m_callback;
+    RefPtrWillBePersistent<RequestEntriesCallback> m_callback;
 };
 
 class DeleteCache : public WebServiceWorkerCacheStorage::CacheStorageCallbacks {
     WTF_MAKE_NONCOPYABLE(DeleteCache);
 
 public:
-    DeleteCache(PassRefPtr<DeleteCacheCallback> callback)
+    DeleteCache(PassRefPtrWillBeRawPtr<DeleteCacheCallback> callback)
         : m_callback(callback)
     {
     }
     virtual ~DeleteCache() { }
 
     void onSuccess()
     {
         m_callback->sendSuccess();
     }
 
     void onError(WebServiceWorkerCacheError* error)
     {
         m_callback->sendFailure(String::format("Error requesting cache names: %s", serviceWorkerCacheErrorString(error).data()));
     }
 
 private:
-    RefPtr<DeleteCacheCallback> m_callback;
+    RefPtrWillBePersistent<DeleteCacheCallback> m_callback;
 };
 
 } // namespace
 
 InspectorServiceWorkerCacheAgent::InspectorServiceWorkerCacheAgent(ServiceWorkerGlobalScope* scope)
     : InspectorBaseAgent<blink::InspectorServiceWorkerCacheAgent>("ServiceWorkerCache")
     , m_globalScope(scope)
 {
 }
 
@@ skipping 36 matching lines @@
 {
     WebServiceWorkerCacheStorage* cache = assertCacheStorage(errorString, m_globalScope);
     if (!cache) {
         callback->sendFailure(*errorString);
         return;
     }
     cache->dispatchDelete(new DeleteCache(callback), WebString(cacheName));
 }
 
 } // namespace blink