CacheStorage: Enable Cache::putImpl to receive multiple requests/responses

Source/modules/cachestorage/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/cachestorage/Cache.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 135 matching lines @@
 public:
     static v8::Local<v8::Function> create(ScriptState* scriptState, Cache* cache, Request* request)
     {
         FetchResolvedForAdd* self = new FetchResolvedForAdd(scriptState, cache, request);
         return self->bindToV8Function();
     }
 
     ScriptValue call(ScriptValue value) override
     {
         Response* response = V8Response::toImplWithTypeCheck(scriptState()->isolate(), value.v8Value());
-        ScriptPromise putPromise = m_cache->putImpl(scriptState(), m_request, response);
+        ScriptPromise putPromise = m_cache->putImpl(scriptState(), HeapVector<Member<Request>>(1, m_request), HeapVector<Member<Response>>(1, response));
         return ScriptValue(scriptState(), putPromise.v8Value());
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_cache);
         visitor->trace(m_request);
         ScriptFunction::trace(visitor);
     }
 
 private:
     FetchResolvedForAdd(ScriptState* scriptState, Cache* cache, Request* request)
         : ScriptFunction(scriptState)
         , m_cache(cache)
         , m_request(request)
     {
     }
 
     Member<Cache> m_cache;
     Member<Request> m_request;
 };
 
-class Cache::AsyncPutBatch final : public BodyStreamBuffer::BlobHandleCreatorClient {
+class Cache::BarrierCallbackForPut final : public GarbageCollectedFinalized<BarrierCallbackForPut> {
 public:
-    AsyncPutBatch(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver, Cache* cache, Request* request, Response* response)
-        : m_resolver(resolver)
+    BarrierCallbackForPut(int numberOfOperations, Cache* cache, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+        : m_numberOfRemainingOperations(numberOfOperations)
         , m_cache(cache)
+        , m_resolver(resolver)
+    {
+        ASSERT(0 < m_numberOfRemainingOperations);
+        m_batchOperations.resize(numberOfOperations);
+    }
+
+    void onSuccess(size_t index, const WebServiceWorkerCache::BatchOperation& batchOperation)
+    {
+        ASSERT(index < m_batchOperations.size());
+        if (m_completed)
+            return;
+        m_batchOperations[index] = batchOperation;
+        if (--m_numberOfRemainingOperations != 0)
+            return;
+        m_cache->webCache()->dispatchBatch(new CallbackPromiseAdapter<void, CacheStorageError>(m_resolver), m_batchOperations);

[sof, 2015/06/30 09:46:46]

Where is m_resolver resolved or cleared?

[nhiroki, 2015/07/01 02:02:20]

m_resolver is resolved in CallbackPromiseAdapter<void, T>::onSuccess()[1] called
from CacheStorageDispatcher::OnCacheBatchSuccess()[2].

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
[2]
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/c...

+    }
+
+    void onError(DOMException* exception)
+    {
+        if (m_completed)
+            return;
+        m_completed = true;
+
+        ScriptState* state = m_resolver->scriptState();
+        ScriptState::Scope scope(state);
+        m_resolver->reject(V8ThrowException::createTypeError(state->isolate(), exception->toString()));
+    }
+
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        visitor->trace(m_cache);
+    }
+
+private:
+    bool m_completed = false;
+    int m_numberOfRemainingOperations;
+    Member<Cache> m_cache;
+    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
+    Vector<WebServiceWorkerCache::BatchOperation> m_batchOperations;
+};
+
+class Cache::BlobHandleCallbackForPut final : public BodyStreamBuffer::BlobHandleCreatorClient {
+public:
+    BlobHandleCallbackForPut(size_t index, BarrierCallbackForPut* barrierCallback, Request* request, Response* response)
+        : m_index(index)
+        , m_barrierCallback(barrierCallback)
     {
         request->populateWebServiceWorkerRequest(m_webRequest);
         response->populateWebServiceWorkerResponse(m_webResponse);
     }
-    ~AsyncPutBatch() override { }
+    ~BlobHandleCallbackForPut() override { }
+
     void didCreateBlobHandle(PassRefPtr<BlobDataHandle> handle) override
     {
-        WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
-        batchOperations[0].operationType = WebServiceWorkerCache::OperationTypePut;
-        batchOperations[0].request = m_webRequest;
-        batchOperations[0].response = m_webResponse;
-        batchOperations[0].response.setBlobDataHandle(handle);
-        m_cache->webCache()->dispatchBatch(new CallbackPromiseAdapter<void, CacheStorageError>(m_resolver.get()), batchOperations);
-        cleanup();
+        WebServiceWorkerCache::BatchOperation batchOperation;
+        batchOperation.operationType = WebServiceWorkerCache::OperationTypePut;
+        batchOperation.request = m_webRequest;
+        batchOperation.response = m_webResponse;
+        batchOperation.response.setBlobDataHandle(handle);
+        m_barrierCallback->onSuccess(m_index, batchOperation);
     }
+
     void didFail(DOMException* exception) override
     {
-        ScriptState* state = m_resolver->scriptState();
-        ScriptState::Scope scope(state);
-        m_resolver->reject(V8ThrowException::createTypeError(state->isolate(), exception->toString()));
-        cleanup();
+        m_barrierCallback->onError(exception);
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
-        visitor->trace(m_resolver);
-        visitor->trace(m_cache);
+        visitor->trace(m_barrierCallback);
         BlobHandleCreatorClient::trace(visitor);
     }
 
 private:
-    void cleanup()
-    {
-        m_resolver = nullptr;
-        m_cache = nullptr;
-    }
-    RefPtrWillBeMember<ScriptPromiseResolver> m_resolver;
-    Member<Cache> m_cache;
+    const size_t m_index;
+    Member<BarrierCallbackForPut> m_barrierCallback;
+
     WebServiceWorkerRequest m_webRequest;
     WebServiceWorkerResponse m_webResponse;
 };
 
 Cache* Cache::create(WeakPtr<GlobalFetch::ScopedFetcher> fetcher, WebServiceWorkerCache* webCache)
 {
     return new Cache(fetcher, webCache);
 }
 
 ScriptPromise Cache::match(ScriptState* scriptState, const RequestInfo& request, const CacheQueryOptions& options, ExceptionState& exceptionState)
@@ skipping 50 matching lines @@
     Request* newRequest = Request::create(scriptState, request.getAsUSVString(), exceptionState);
     if (exceptionState.hadException())
         return ScriptPromise();
     return deleteImpl(scriptState, newRequest, options);
 }
 
 ScriptPromise Cache::put(ScriptState* scriptState, const RequestInfo& request, Response* response, ExceptionState& exceptionState)
 {
     ASSERT(!request.isNull());
     if (request.isRequest())
-        return putImpl(scriptState, request.getAsRequest(), response);
+        return putImpl(scriptState, HeapVector<Member<Request>>(1, request.getAsRequest()), HeapVector<Member<Response>>(1, response));
     Request* newRequest = Request::create(scriptState, request.getAsUSVString(), exceptionState);
     if (exceptionState.hadException())
         return ScriptPromise();
-    return putImpl(scriptState, newRequest, response);
+    return putImpl(scriptState, HeapVector<Member<Request>>(1, newRequest), HeapVector<Member<Response>>(1, response));
 }
 
 ScriptPromise Cache::keys(ScriptState* scriptState, ExceptionState&)
 {
     return keysImpl(scriptState);
 }
 
 ScriptPromise Cache::keys(ScriptState* scriptState, const RequestInfo& request, const CacheQueryOptions& options, ExceptionState& exceptionState)
 {
     ASSERT(!request.isNull());
@@ skipping 67 matching lines @@
     batchOperations[0].operationType = WebServiceWorkerCache::OperationTypeDelete;
     request->populateWebServiceWorkerRequest(batchOperations[0].request);
     batchOperations[0].matchParams = toWebQueryParams(options);
 
     RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchBatch(new CacheDeleteCallback(resolver), batchOperations);
     return promise;
 }
 
-ScriptPromise Cache::putImpl(ScriptState* scriptState, Request* request, Response* response)
+ScriptPromise Cache::putImpl(ScriptState* scriptState, const HeapVector<Member<Request>>& requests, const HeapVector<Member<Response>>& responses)
 {
-    KURL url(KURL(), request->url());
-    if (!url.protocolIsInHTTPFamily())
-        return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request scheme '" + url.protocol() + "' is unsupported"));
-    if (request->method() != "GET")
-        return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request method '" + request->method() + "' is unsupported"));
-    if (request->hasBody() && request->bodyUsed())
-        return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request body is already used"));
-    if (response->hasBody() && response->bodyUsed())
-        return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Response body is already used"));
-
-    if (request->hasBody())
-        request->lockBody(Body::PassBody);
-    if (response->hasBody())
-        response->lockBody(Body::PassBody);
-
     RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
-    if (BodyStreamBuffer* buffer = response->internalBuffer()) {
-        if (buffer == response->buffer() && response->isBodyConsumed())
-            buffer = response->createDrainingStream();
-        // If the response body type is stream, read the all data and create the
-        // blob handle and dispatch the put batch asynchronously.
-        buffer->readAllAndCreateBlobHandle(response->internalMIMEType(), new AsyncPutBatch(resolver, this, request, response));
-        return promise;
+    BarrierCallbackForPut* barrierCallback = new BarrierCallbackForPut(requests.size(), this, resolver.get());
+
+    for (size_t i = 0; i < requests.size(); ++i) {
+        KURL url(KURL(), requests[i]->url());
+        if (!url.protocolIsInHTTPFamily())
+            return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request scheme '" + url.protocol() + "' is unsupported"));
+        if (requests[i]->method() != "GET")
+            return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request method '" + requests[i]->method() + "' is unsupported"));
+        if (requests[i]->hasBody() && requests[i]->bodyUsed())
+            return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request body is already used"));
+        if (responses[i]->hasBody() && responses[i]->bodyUsed())
+            return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Response body is already used"));
+
+        if (requests[i]->hasBody())
+            requests[i]->lockBody(Body::PassBody);
+        if (responses[i]->hasBody())
+            responses[i]->lockBody(Body::PassBody);
+
+        if (BodyStreamBuffer* buffer = responses[i]->internalBuffer()) {
+            if (buffer == responses[i]->buffer() && responses[i]->isBodyConsumed())
+                buffer = responses[i]->createDrainingStream();
+            // If the response body type is stream, read the all data and create
+            // the blob handle and dispatch the put batch asynchronously.
+            buffer->readAllAndCreateBlobHandle(responses[i]->internalMIMEType(), new BlobHandleCallbackForPut(i, barrierCallback, requests[i], responses[i]));
+            continue;
+        }
+
+        WebServiceWorkerCache::BatchOperation batchOperation;
+        batchOperation.operationType = WebServiceWorkerCache::OperationTypePut;
+        requests[i]->populateWebServiceWorkerRequest(batchOperation.request);
+        responses[i]->populateWebServiceWorkerResponse(batchOperation.response);
+        barrierCallback->onSuccess(i, batchOperation);
     }
-    WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
-    batchOperations[0].operationType = WebServiceWorkerCache::OperationTypePut;
-    request->populateWebServiceWorkerRequest(batchOperations[0].request);
-    response->populateWebServiceWorkerResponse(batchOperations[0].response);
 
-    m_webCache->dispatchBatch(new CallbackPromiseAdapter<void, CacheStorageError>(resolver), batchOperations);
     return promise;
 }
 
 ScriptPromise Cache::keysImpl(ScriptState* scriptState)
 {
     RefPtrWillBeRawPtr<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, const Request* request, const CacheQueryOptions& options)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
 
     RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, toWebQueryParams(options));
     return promise;
 }
 
 WebServiceWorkerCache* Cache::webCache() const
 {
     return m_webCache.get();
 }
 
 } // namespace blink