Remove FetchFormDataConsumerHandle use in SRIVerifier

third_party/WebKit/Source/modules/fetch/FetchManager.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 "modules/fetch/FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/Document.h"
 #include "core/fetch/FetchUtils.h"
 #include "core/fileapi/Blob.h"
 #include "core/frame/Frame.h"
 #include "core/frame/SubresourceIntegrity.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "modules/fetch/Body.h"
 #include "modules/fetch/BodyStreamBuffer.h"
-#include "modules/fetch/CompositeDataConsumerHandle.h"
+#include "modules/fetch/BytesConsumer.h"
+#include "modules/fetch/BytesConsumerForDataConsumerHandle.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
-#include "modules/fetch/FetchFormDataConsumerHandle.h"
 #include "modules/fetch/FetchRequestData.h"
+#include "modules/fetch/FormDataBytesConsumer.h"
 #include "modules/fetch/Response.h"
 #include "modules/fetch/ResponseInit.h"
 #include "platform/HTTPNames.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/HashSet.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 bool IsRedirectStatusCode(int statusCode)
 {
     return (statusCode == 301 || statusCode == 302 || statusCode == 303 || statusCode == 307 || statusCode == 308);
 }
 
+class SRIBytesConsumer final : public BytesConsumer {
+public:
+    // BytesConsumer implementation
+    Result beginRead(const char** buffer, size_t* available) override
+    {
+        if (!m_underlying) {
+            *buffer = nullptr;
+            *available = 0;
+            return m_isCancelled ? Result::Done : Result::ShouldWait;
+        }
+        return m_underlying->beginRead(buffer, available);
+    }
+    Result endRead(size_t readSize) override
+    {
+        DCHECK(m_underlying);
+        return m_underlying->endRead(readSize);
+    }
+    PassRefPtr<BlobDataHandle> drainAsBlobDataHandle(BlobSizePolicy policy) override
+    {
+        return m_underlying ? m_underlying->drainAsBlobDataHandle(policy) : nullptr;
+    }
+    PassRefPtr<EncodedFormData> drainAsFormData() override
+    {
+        return m_underlying ? m_underlying->drainAsFormData() : nullptr;
+    }
+    void setClient(BytesConsumer::Client* client) override
+    {
+        DCHECK(!m_client);
+        DCHECK(client);
+        if (m_underlying)
+            m_underlying->setClient(client);
+        else
+            m_client = client;
+    }
+    void clearClient() override
+    {
+        if (m_underlying)
+            m_underlying->clearClient();
+        else
+            m_client = nullptr;
+    }
+    void cancel() override
+    {
+        if (m_underlying) {
+            m_underlying->cancel();
+        } else {
+            m_isCancelled = true;
+            m_client = nullptr;
+        }
+    }
+    PublicState getPublicState() const override
+    {
+        return m_underlying ? m_underlying->getPublicState() : m_isCancelled ? PublicState::Closed : PublicState::ReadableOrWaiting;
+    }
+    Error getError() const override
+    {
+        DCHECK(m_underlying);
+        // We must not be in the errored state until we get updated.
+        return m_underlying->getError();
+    }
+    String debugName() const override
+    {
+        return "SRIBytesConsumer";
+    }
+
+    // This function can be called at most once.
+    void update(BytesConsumer* consumer)
+    {
+        DCHECK(!m_underlying);
+        if (m_isCancelled) {
+            // This consumer has already been closed.
+            return;
+        }
+
+        m_underlying = consumer;
+        if (m_client) {
+            Client* client = m_client;
+            m_client = nullptr;
+            m_underlying->setClient(client);
+            if (getPublicState() != PublicState::ReadableOrWaiting)
+                client->onStateChange();
+        }
+    }
+
+    DEFINE_INLINE_TRACE()
+    {
+        visitor->trace(m_underlying);
+        visitor->trace(m_client);
+        BytesConsumer::trace(visitor);
+    }
+
+private:
+    Member<BytesConsumer> m_underlying;
+    Member<Client> m_client;
+    bool m_isCancelled = false;
+};
+
+
 } // namespace
 
 class FetchManager::Loader final : public GarbageCollectedFinalized<FetchManager::Loader>, public ThreadableLoaderClient {
     USING_PRE_FINALIZER(FetchManager::Loader, dispose);
 public:
     static Loader* create(ExecutionContext* executionContext, FetchManager* fetchManager, ScriptPromiseResolver* resolver, FetchRequestData* request, bool isIsolatedWorld)
     {
         return new Loader(executionContext, fetchManager, resolver, request, isIsolatedWorld);
     }
 
     ~Loader() override;
     DECLARE_VIRTUAL_TRACE();
 
     void didReceiveResponse(unsigned long, const ResourceResponse&, std::unique_ptr<WebDataConsumerHandle>) override;
     void didFinishLoading(unsigned long, double) override;
     void didFail(const ResourceError&) override;
     void didFailAccessControlCheck(const ResourceError&) override;
     void didFailRedirectCheck() override;
 
     void start();
     void dispose();
 
     class SRIVerifier final : public GarbageCollectedFinalized<SRIVerifier>, public WebDataConsumerHandle::Client {
     public:
         // Promptly clear m_handle and m_reader.
         EAGERLY_FINALIZE();
         // SRIVerifier takes ownership of |handle| and |response|.
         // |updater| must be garbage collected. The other arguments
         // all must have the lifetime of the give loader.
-        SRIVerifier(std::unique_ptr<WebDataConsumerHandle> handle, CompositeDataConsumerHandle::Updater* updater, Response* response, FetchManager::Loader* loader, String integrityMetadata, const KURL& url)
+        SRIVerifier(std::unique_ptr<WebDataConsumerHandle> handle, SRIBytesConsumer* updater, Response* response, FetchManager::Loader* loader, String integrityMetadata, const KURL& url)
             : m_handle(std::move(handle))
             , m_updater(updater)
             , m_response(response)
             , m_loader(loader)
             , m_integrityMetadata(integrityMetadata)
             , m_url(url)
             , m_finished(false)
         {
             m_reader = m_handle->obtainReader(this);
         }
@@ skipping 13 matching lines @@
                     m_buffer.append(static_cast<const char*>(buffer), size);
                     m_reader->endRead(size);
                 }
             }
             if (r == WebDataConsumerHandle::ShouldWait)
                 return;
             String errorMessage = "Unknown error occurred while trying to verify integrity.";
             m_finished = true;
             if (r == WebDataConsumerHandle::Done) {
                 if (SubresourceIntegrity::CheckSubresourceIntegrity(m_integrityMetadata, m_buffer.data(), m_buffer.size(), m_url, *m_loader->document(), errorMessage)) {
-                    m_updater->update(FetchFormDataConsumerHandle::create(m_buffer.data(), m_buffer.size()));
+                    m_updater->update(new FormDataBytesConsumer(m_buffer.data(), m_buffer.size()));
                     m_loader->m_resolver->resolve(m_response);
                     m_loader->m_resolver.clear();
                     // FetchManager::Loader::didFinishLoading() can
                     // be called before didGetReadable() is called
                     // when the data is ready. In that case,
                     // didFinishLoading() doesn't clean up and call
                     // notifyFinished(), so it is necessary to
                     // explicitly finish the loader here.
                     if (m_loader->m_didFinishLoading)
                         m_loader->loadSucceeded();
                     return;
                 }
             }
-            m_updater->update(createUnexpectedErrorDataConsumerHandle());
+            m_updater->update(new BytesConsumerForDataConsumerHandle(m_response->getExecutionContext(), createFetchDataConsumerHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle())));
             m_loader->performNetworkError(errorMessage);
         }
 
         bool isFinished() const { return m_finished; }
 
         DEFINE_INLINE_TRACE()
         {
             visitor->trace(m_updater);
             visitor->trace(m_response);
             visitor->trace(m_loader);
         }
     private:
         std::unique_ptr<WebDataConsumerHandle> m_handle;
-        Member<CompositeDataConsumerHandle::Updater> m_updater;
+        Member<SRIBytesConsumer> m_updater;
         // We cannot store a Response because its JS wrapper can be collected.
         // TODO(yhirano): Fix this.
         Member<Response> m_response;
         Member<FetchManager::Loader> m_loader;
         String m_integrityMetadata;
         KURL m_url;
         std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
         Vector<char> m_buffer;
         bool m_finished;
     };
@@ skipping 133 matching lines @@
         case WebServiceWorkerResponseTypeError:
             // When ServiceWorker respond to the request from fetch() with an
             // error response, FetchManager::Loader::didFail() must be called
             // instead.
             RELEASE_NOTREACHED();
             break;
         }
     }
 
     FetchResponseData* responseData = nullptr;
-    CompositeDataConsumerHandle::Updater* updater = nullptr;
-    if (m_request->integrity().isEmpty())
+    SRIBytesConsumer* sriConsumer = nullptr;
+    if (m_request->integrity().isEmpty()) {
         responseData = FetchResponseData::createWithBuffer(new BodyStreamBuffer(scriptState, createFetchDataConsumerHandleFromWebHandle(std::move(handle))));
-    else
-        responseData = FetchResponseData::createWithBuffer(new BodyStreamBuffer(scriptState, createFetchDataConsumerHandleFromWebHandle(CompositeDataConsumerHandle::create(createWaitingDataConsumerHandle(), &updater))));
+    } else {
+        sriConsumer = new SRIBytesConsumer();
+        responseData = FetchResponseData::createWithBuffer(new BodyStreamBuffer(scriptState, sriConsumer));
+    }
     responseData->setStatus(response.httpStatusCode());
     responseData->setStatusMessage(response.httpStatusText());
     for (auto& it : response.httpHeaderFields())
         responseData->headerList()->append(it.key, it.value);
     responseData->setURL(response.url());
     responseData->setMIMEType(response.mimeType());
     responseData->setResponseTime(response.responseTime());
 
     FetchResponseData* taintedResponse = nullptr;
 
@@ skipping 44 matching lines @@
         //  parameters returned from obtaining a resource"
         r->headers()->headerList()->remove(HTTPNames::Access_Control_Allow_Origin);
     }
     r->headers()->setGuard(Headers::ImmutableGuard);
 
     if (m_request->integrity().isEmpty()) {
         m_resolver->resolve(r);
         m_resolver.clear();
     } else {
         ASSERT(!m_integrityVerifier);
-        m_integrityVerifier = new SRIVerifier(std::move(handle), updater, r, this, m_request->integrity(), response.url());
+        m_integrityVerifier = new SRIVerifier(std::move(handle), sriConsumer, r, this, m_request->integrity(), response.url());
     }
 }
 
 void FetchManager::Loader::didFinishLoading(unsigned long, double)
 {
     m_didFinishLoading = true;
     // If there is an integrity verifier, and it has not already finished, it
     // will take care of finishing the load or performing a network error when
     // verification is complete.
     if (m_integrityVerifier && !m_integrityVerifier->isFinished())
@@ skipping 363 matching lines @@
     loader->dispose();
 }
 
 DEFINE_TRACE(FetchManager)
 {
     visitor->trace(m_loaders);
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink