BytesConsumer::endRead can return Done

third_party/WebKit/Source/modules/fetch/FetchDataLoader.cpp

 // Copyright 2015 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/FetchDataLoader.h"
 
 #include "core/html/parser/TextResourceDecoder.h"
 #include "modules/fetch/BytesConsumer.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/StringBuilder.h"
@@ skipping 42 matching lines @@
     void cancel() override
     {
         m_consumer->cancel();
     }
 
     void onStateChange() override
     {
         while (true) {
             const char* buffer;
             size_t available;
-            switch (m_consumer->beginRead(&buffer, &available)) {
+            auto result = m_consumer->beginRead(&buffer, &available);
+            if (result == BytesConsumer::Result::ShouldWait)
+                return;
+            if (result == BytesConsumer::Result::Ok) {
+                m_blobData->appendBytes(buffer, available);
+                result = m_consumer->endRead(available);
+            }
+            switch (result) {
             case BytesConsumer::Result::Ok:
-                m_blobData->appendBytes(buffer, available);
-                if (m_consumer->endRead(available) != BytesConsumer::Result::Ok) {
-                    m_client->didFetchDataLoadFailed();
-                    return;
-                }
                 break;
             case BytesConsumer::Result::ShouldWait:
+                NOTREACHED();
                 return;
             case BytesConsumer::Result::Done: {
                 auto size = m_blobData->length();
                 m_client->didFetchDataLoadedBlobHandle(BlobDataHandle::create(std::move(m_blobData), size));
                 return;
             }
             case BytesConsumer::Result::Error:
                 m_client->didFetchDataLoadFailed();
                 return;
             }
@@ skipping 34 matching lines @@
     void cancel() override
     {
         m_consumer->cancel();
     }
 
     void onStateChange() override
     {
         while (true) {
             const char* buffer;
             size_t available;
-            switch (m_consumer->beginRead(&buffer, &available)) {
-            case BytesConsumer::Result::Ok:
+            auto result = m_consumer->beginRead(&buffer, &available);
+            if (result == BytesConsumer::Result::ShouldWait)
+                return;
+            if (result == BytesConsumer::Result::Ok) {
                 if (available > 0) {
                     unsigned bytesAppended = m_rawData->append(buffer, available);
                     if (!bytesAppended) {
                         auto unused = m_consumer->endRead(0);
                         ALLOW_UNUSED_LOCAL(unused);
                         m_consumer->cancel();
                         m_client->didFetchDataLoadFailed();
                         return;
                     }
                     DCHECK_EQ(bytesAppended, available);
                 }
-                if (m_consumer->endRead(available) != BytesConsumer::Result::Ok) {
-                    m_client->didFetchDataLoadFailed();
-                    return;
-                }
+                result = m_consumer->endRead(available);
+            }
+            switch (result) {
+            case BytesConsumer::Result::Ok:
                 break;
             case BytesConsumer::Result::ShouldWait:
+                NOTREACHED();
                 return;
             case BytesConsumer::Result::Done:
                 m_client->didFetchDataLoadedArrayBuffer(DOMArrayBuffer::create(m_rawData->toArrayBuffer()));
                 return;
             case BytesConsumer::Result::Error:
                 m_client->didFetchDataLoadFailed();
                 return;
             }
         }
     }
@@ skipping 26 matching lines @@
         m_consumer = consumer;
         m_consumer->setClient(this);
         onStateChange();
     }
 
     void onStateChange() override
     {
         while (true) {
             const char* buffer;
             size_t available;
-            switch (m_consumer->beginRead(&buffer, &available)) {
-            case BytesConsumer::Result::Ok:
+            auto result = m_consumer->beginRead(&buffer, &available);
+            if (result == BytesConsumer::Result::ShouldWait)
+                return;
+            if (result == BytesConsumer::Result::Ok) {
                 if (available > 0)
                     m_builder.append(m_decoder->decode(buffer, available));
-                if (m_consumer->endRead(available) != BytesConsumer::Result::Ok) {
-                    m_client->didFetchDataLoadFailed();
-                    return;
-                }
+                result = m_consumer->endRead(available);
+            }
+            switch (result) {
+            case BytesConsumer::Result::Ok:
                 break;
             case BytesConsumer::Result::ShouldWait:
+                NOTREACHED();
                 return;
             case BytesConsumer::Result::Done:
                 m_builder.append(m_decoder->flush());
                 m_client->didFetchDataLoadedString(m_builder.toString());
                 return;
             case BytesConsumer::Result::Error:
                 m_client->didFetchDataLoadFailed();
                 return;
             }
         }
@@ skipping 37 matching lines @@
         m_consumer->setClient(this);
         onStateChange();
     }
 
     void onStateChange() override
     {
         bool needToFlush = false;
         while (true) {
             const char* buffer;
             size_t available;
-            switch (m_consumer->beginRead(&buffer, &available)) {
-            case BytesConsumer::Result::Ok:
-                m_outStream->addData(buffer, available);
-                if (m_consumer->endRead(available) != BytesConsumer::Result::Ok) {
-                    m_outStream->abort();
-                    m_client->didFetchDataLoadFailed();
-                    return;
-                }
-                needToFlush = true;
-                break;
-            case BytesConsumer::Result::ShouldWait:
+            auto result = m_consumer->beginRead(&buffer, &available);
+            if (result == BytesConsumer::Result::ShouldWait) {
                 if (needToFlush)
                     m_outStream->flush();
                 return;
+            }
+            if (result == BytesConsumer::Result::Ok) {
+                m_outStream->addData(buffer, available);
+                needToFlush = true;
+                result = m_consumer->endRead(available);
+            }
+            switch (result) {
+            case BytesConsumer::Result::Ok:
+                break;
+            case BytesConsumer::Result::ShouldWait:
+                NOTREACHED();
+                return;
             case BytesConsumer::Result::Done:
                 if (needToFlush)
                     m_outStream->flush();
                 m_outStream->finalize();
                 m_client->didFetchDataLoadedStream();
                 return;
             case BytesConsumer::Result::Error:
                 // If the stream is aborted soon after the stream is registered
                 // to the StreamRegistry, ServiceWorkerURLRequestJob may not
                 // notice the error and continue waiting forever.
@@ skipping 41 matching lines @@
 {
     return new FetchDataLoaderAsString();
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsStream(Stream* outStream)
 {
     return new FetchDataLoaderAsStream(outStream);
 }
 
 } // namespace blink