Service Workers: Cache.put() should resolve to undefined

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/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ThrowException.h"
@@ skipping 60 matching lines @@
     {
         m_resolver->reject(Cache::domExceptionForCacheError(*reason));
         m_resolver.clear();
     }
 
 protected:
     RefPtr<ScriptPromiseResolver> m_resolver;
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
-class CacheWithOneResponseCallbacks : public CacheWithResponsesCallbacks {
-    WTF_MAKE_NONCOPYABLE(CacheWithOneResponseCallbacks);
+class CacheAddOrPutCallbacks : public CacheWithResponsesCallbacks {
+    WTF_MAKE_NONCOPYABLE(CacheAddOrPutCallbacks);
 public:
-    CacheWithOneResponseCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
+    CacheAddOrPutCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
         : CacheWithResponsesCallbacks(resolver) { }
 
     virtual void onSuccess(WebVector<WebServiceWorkerResponse>* webResponses) override
     {
-        ASSERT(webResponses->size() == 1);
-        m_resolver->resolve(Response::create(m_resolver->scriptState()->executionContext(), (*webResponses)[0]));
+        // FIXME: Since response is ignored, consider simplifying public API.
+        m_resolver->resolve();
         m_resolver.clear();
     }
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheDeleteCallback : public WebServiceWorkerCache::CacheWithResponsesCallbacks {
     WTF_MAKE_NONCOPYABLE(CacheDeleteCallback);
 public:
     CacheDeleteCallback(PassRefPtr<ScriptPromiseResolver> resolver)
         : m_resolver(resolver) { }
 
     virtual void onSuccess(WebVector<WebServiceWorkerResponse>* webResponses) override
     {
+        // FIXME: Since response is ignored, consider simplifying public API.
         m_resolver->resolve(true);
         m_resolver.clear();
     }
 
     virtual void onError(WebServiceWorkerCacheError* reason) override
     {
         if (*reason == WebServiceWorkerCacheErrorNotFound)
             m_resolver->resolve(false);
         else
             m_resolver->reject(Cache::domExceptionForCacheError(*reason));
@@ skipping 263 matching lines @@
     if (request->method() != "GET")
         return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError("Request method '" + request->method() + "' is unsupported", scriptState->isolate()));
 
     WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
     batchOperations[0].operationType = WebServiceWorkerCache::OperationTypePut;
     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 CacheWithOneResponseCallbacks(resolver), batchOperations);
+    m_webCache->dispatchBatch(new CacheAddOrPutCallbacks(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, Request* request, const CacheQueryOptions& options)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, toWebQueryParams(options));
     return promise;
 }
 
 } // namespace blink