[ServiceWorker] Create a new Blob when body.asBody() is called if the size of body is not set.

Source/modules/serviceworkers/FetchBodyStream.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/FetchBodyStream.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ThrowException.h"
@@ skipping 26 matching lines @@
     m_resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = m_resolver->promise();
 
     FileReaderLoader::ReadType readType = FileReaderLoader::ReadAsText;
 
     switch (type) {
     case ResponseAsArrayBuffer:
         readType = FileReaderLoader::ReadAsArrayBuffer;
         break;
     case ResponseAsBlob:
-        m_resolver->resolve(Blob::create(m_blobDataHandle));
-        m_resolver.clear();
-        return promise;
+        if (m_blobDataHandle->size() != kuint64max) {
+            // If the size of |m_blobDataHandle| is set correctly, creates Blob from it.
+            m_resolver->resolve(Blob::create(m_blobDataHandle));
+            m_resolver.clear();
+            return promise;
+        }
+        // If the size is not set, read as ArrayBuffer and create a new blob to get the size.
+        // FIXME: This workaround is not good for performance.
+        // When we will stop using Blob as a base system of FetchBodyStream to support stream, this problem should be solved.
+        readType = FileReaderLoader::ReadAsArrayBuffer;
+        break;
     case ResponseAsFormData:
         // FIXME: Implement this.
         ASSERT_NOT_REACHED();
         break;
     case ResponseAsJSON:
     case ResponseAsText:
         break;
     default:
         ASSERT_NOT_REACHED();
     }
@@ skipping 72 matching lines @@
 
 // FileReaderLoaderClient functions.
 void FetchBodyStream::didStartLoading() { }
 void FetchBodyStream::didReceiveData() { }
 void FetchBodyStream::didFinishLoading()
 {
     switch (m_responseType) {
     case ResponseAsArrayBuffer:
         m_resolver->resolve(m_loader->arrayBufferResult());
         break;
-    case ResponseAsBlob:
-        // Handled in ::readAsync().
-        ASSERT_NOT_REACHED();
+    case ResponseAsBlob: {
+        ASSERT(m_blobDataHandle->size() == kuint64max);
+        OwnPtr<BlobData> blobData = BlobData::create();
+        RefPtr<ArrayBuffer> buffer = m_loader->arrayBufferResult();
+        blobData->appendArrayBuffer(buffer.get());
+        const size_t length = blobData->length();
+        m_resolver->resolve(Blob::create(BlobDataHandle::create(blobData.release(), length)));
         break;
+    }
     case ResponseAsFormData:
         ASSERT_NOT_REACHED();
         break;
     case ResponseAsJSON:
         resolveJSON();
         break;
     case ResponseAsText:
         m_resolver->resolve(m_loader->stringResult());
         break;
     default:
         ASSERT_NOT_REACHED();
     }
     m_resolver.clear();
 }
 
 void FetchBodyStream::didFail(FileError::ErrorCode code)
 {
     ASSERT(m_resolver);
     m_resolver->resolve("");
     m_resolver.clear();
 }
 
 } // namespace blink