Patch on top of https://codereview.chromium.org/433793002/

Source/modules/serviceworkers/Cache.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/Cache.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 45 matching lines @@
 };
 
 class CacheWithResponsesCallbacks : public WebServiceWorkerCache::CacheWithResponsesCallbacks {
     WTF_MAKE_NONCOPYABLE(CacheWithResponsesCallbacks);
 public:
     CacheWithResponsesCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
         : m_resolver(resolver) { }
 
     virtual void onSuccess(WebVector<WebServiceWorkerResponse>* webResponses) OVERRIDE
     {
-        Vector<RefPtrWillBeRawPtr<Response> > responses;
+        Vector<Response*> responses;
         for (size_t i = 0; i < webResponses->size(); ++i)
             responses.append(Response::create((*webResponses)[i]));
         m_resolver->resolve(responses);
         m_resolver.clear();
     }
 
     virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE
     {
         m_resolver->reject(Cache::domExceptionForCacheError(*reason));
         m_resolver.clear();
     }
 
 private:
     RefPtr<ScriptPromiseResolver> m_resolver;
 };
 
 class CacheWithRequestsCallbacks : public WebServiceWorkerCache::CacheWithRequestsCallbacks {
     WTF_MAKE_NONCOPYABLE(CacheWithRequestsCallbacks);
 public:
     CacheWithRequestsCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
         : m_resolver(resolver) { }
 
     virtual void onSuccess(WebVector<WebServiceWorkerRequest>* webRequests) OVERRIDE
     {
-        Vector<RefPtrWillBeRawPtr<Request> > requests;
+        Vector<Request*> requests;
         for (size_t i = 0; i < webRequests->size(); ++i)
             requests.append(Request::create((*webRequests)[i]));
         m_resolver->resolve(requests);
         m_resolver.clear();
     }
 
     virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE
     {
         m_resolver->reject(Cache::domExceptionForCacheError(*reason));
         m_resolver.clear();
@@ skipping 15 matching lines @@
 
 } // namespace
 
 Cache* Cache::fromWebServiceWorkerCache(WebServiceWorkerCache* webCache)
 {
     if (Cache* cache = static_cast<Cache*>(webCache->proxyInterface()))
         return cache;
     return create(webCache);
 }
 
-ScriptPromise Cache::match(ScriptState* scriptState, Request* originalRequest, const Dictionary& queryParamsDict)
+ScriptPromise Cache::match(ScriptState* scriptState, const Request* originalRequest, const Dictionary& queryParamsDict)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return matchImpl(scriptState, request, queryParamsDict);
 }
 
 ScriptPromise Cache::match(ScriptState* scriptState, const String& requestString, const Dictionary& queryParamsDict)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return matchImpl(scriptState, request, queryParamsDict);
 }
 
-ScriptPromise Cache::matchAll(ScriptState* scriptState, Request* originalRequest, const Dictionary& queryParamsDict)
+ScriptPromise Cache::matchAll(ScriptState* scriptState, const Request* originalRequest, const Dictionary& queryParamsDict)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return matchAllImpl(scriptState, request, queryParamsDict);
 }
 
 ScriptPromise Cache::matchAll(ScriptState* scriptState, const String& requestString, const Dictionary& queryParamsDict)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return matchAllImpl(scriptState, request, queryParamsDict);
 }
 
-ScriptPromise Cache::add(ScriptState* scriptState, Request* originalRequest)
+ScriptPromise Cache::add(ScriptState* scriptState, const Request* originalRequest)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return addImpl(scriptState, request);
 }
 
 ScriptPromise Cache::add(ScriptState* scriptState, const String& requestString)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return addImpl(scriptState, request);
 }
 
 ScriptPromise Cache::addAll(ScriptState* scriptState, const Vector<ScriptValue>& rawRequests)
 {
     // FIXME: Implement this.
     return rejectAsNotImplemented(scriptState);
 }
 
-ScriptPromise Cache::deleteFunction(ScriptState* scriptState, Request* originalRequest, const Dictionary& queryParamsDict)
+ScriptPromise Cache::deleteFunction(ScriptState* scriptState, const Request* originalRequest, const Dictionary& queryParamsDict)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return deleteImpl(scriptState, request, queryParamsDict);
 }
 
 ScriptPromise Cache::deleteFunction(ScriptState* scriptState, const String& requestString, const Dictionary& queryParamsDict)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return deleteImpl(scriptState, request, queryParamsDict);
 }
 
-ScriptPromise Cache::put(ScriptState* scriptState, Request* originalRequest, Response* response)
+ScriptPromise Cache::put(ScriptState* scriptState, const Request* originalRequest, const Response* response)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return putImpl(scriptState, request, response);
 }
 
-ScriptPromise Cache::put(ScriptState* scriptState, const String& requestString, Response* response)
+ScriptPromise Cache::put(ScriptState* scriptState, const String& requestString, const Response* response)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return putImpl(scriptState, request, response);
 }
 
 ScriptPromise Cache::keys(ScriptState* scriptState)
 {
     return keysImpl(scriptState);
 }
 
-ScriptPromise Cache::keys(ScriptState* scriptState, Request* originalRequest, const Dictionary& queryParamsDict)
+ScriptPromise Cache::keys(ScriptState* scriptState, const Request* originalRequest, const Dictionary& queryParamsDict)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    return keysImpl(scriptState);
+    return keysImpl(scriptState, request, queryParamsDict);
 }
 
 ScriptPromise Cache::keys(ScriptState* scriptState, const String& requestString, const Dictionary& queryParamsDict)
 {
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<Request> request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
     if (exceptionState.hadException())
         return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
     return keysImpl(scriptState, request, queryParamsDict);
 }
 
 Cache::Cache(WebServiceWorkerCache* webCache)
     : m_webCache(adoptPtr(webCache))
 {
     ScriptWrappable::init(this);
     ASSERT(!m_webCache->proxyInterface());
     m_webCache->setProxyInterface(this);
 }
 
-PassRefPtrWillBeRawPtr<Cache> Cache::create(WebServiceWorkerCache* webCache)
+Cache* Cache::create(WebServiceWorkerCache* webCache)
 {
-    return adoptRefWillBeNoop(new Cache(webCache));
+    return new Cache(webCache);
 }
 
-ScriptPromise Cache::matchImpl(ScriptState* scriptState, PassRefPtrWillBeRawPtr<Request> request, const Dictionary& queryParamsDict)
+ScriptPromise Cache::matchImpl(ScriptState* scriptState, Request* request, const Dictionary& queryParamsDict)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchMatch(new CacheMatchCallbacks(resolver), webRequest, queryParamsFromDictionary(queryParamsDict));
     return promise;
 }
 
-ScriptPromise Cache::matchAllImpl(ScriptState* scriptState, PassRefPtrWillBeRawPtr<Request> request, const Dictionary& queryParamsDict)
+ScriptPromise Cache::matchAllImpl(ScriptState* scriptState, Request* request, const Dictionary& queryParamsDict)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchMatchAll(new CacheWithResponsesCallbacks(resolver), webRequest, queryParamsFromDictionary(queryParamsDict));
     return promise;
 }
 
-ScriptPromise Cache::addImpl(ScriptState* scriptState, PassRefPtrWillBeRawPtr<Request>)
+ScriptPromise Cache::addImpl(ScriptState* scriptState, Request*)
 {
     // FIXME: Implement this.
     return rejectAsNotImplemented(scriptState);
 }
 
-ScriptPromise Cache::addAllImpl(ScriptState* scriptState, Vector<RefPtrWillBeRawPtr<Request> >)
+ScriptPromise Cache::addAllImpl(ScriptState* scriptState, Vector<Request*>)
 {
     // FIXME: Implement this.
     return rejectAsNotImplemented(scriptState);
 }
 
 PassRefPtrWillBeRawPtr<DOMException> Cache::domExceptionForCacheError(WebServiceWorkerCacheError reason)
 {
     switch (reason) {
     case WebServiceWorkerCacheErrorNotImplemented:
         return DOMException::create(NotSupportedError, "Method is not implemented.");
     case WebServiceWorkerCacheErrorNotFound:
         return DOMException::create(NotFoundError, "Entry was not found.");
     case WebServiceWorkerCacheErrorExists:
         return DOMException::create(InvalidAccessError, "Entry already exists.");
     default:
         ASSERT_NOT_REACHED();
         return DOMException::create(NotSupportedError, "Unknown error.");
     }
 }
 
-ScriptPromise Cache::deleteImpl(ScriptState* scriptState, PassRefPtrWillBeRawPtr<Request> request, const Dictionary& queryParamsDict)
+ScriptPromise Cache::deleteImpl(ScriptState* scriptState, Request* request, const Dictionary& queryParamsDict)
 {
     WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
     batchOperations[0].operationType = WebServiceWorkerCache::WebServiceWorkerCacheOperationTypeDelete;
     request->populateWebServiceWorkerRequest(batchOperations[0].request);
     batchOperations[0].matchParams = queryParamsFromDictionary(queryParamsDict);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchBatch(new CacheWithResponsesCallbacks(resolver), batchOperations);
     return promise;
 }
 
-ScriptPromise Cache::putImpl(ScriptState* scriptState, PassRefPtrWillBeRawPtr<Request> request, Response* response)
+ScriptPromise Cache::putImpl(ScriptState* scriptState, Request* request, const Response* response)
 {
     WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
     batchOperations[0].operationType = WebServiceWorkerCache::WebServiceWorkerCacheOperationTypePut;
     request->populateWebServiceWorkerRequest(batchOperations[0].request);
     response->populateWebServiceWorkerResponse(batchOperations[0].response);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchBatch(new CacheWithResponsesCallbacks(resolver), batchOperations);
     return promise;
 }
 
 ScriptPromise Cache::keysImpl(ScriptState* scriptState)
 {
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, WebServiceWorkerCache::QueryParams());
     return promise;
 }
 
-ScriptPromise Cache::keysImpl(ScriptState* scriptState, PassRefPtrWillBeRawPtr<Request> request, const Dictionary& queryParamsDict)
+ScriptPromise Cache::keysImpl(ScriptState* scriptState, Request* request, const Dictionary& queryParamsDict)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, queryParamsFromDictionary(queryParamsDict));
     return promise;
 }
 
 } // namespace blink