**** [WIP] Blink-side: Implement FetchBlobDataConsumerHandle ****

Source/modules/fetch/ResponseTest.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/fetch/Response.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/Document.h"
 #include "core/frame/Frame.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/fetch/FetchResponseData.h"
 #include "platform/blob/BlobData.h"
 #include "public/platform/WebServiceWorkerResponse.h"
 #include <gtest/gtest.h>
 
 namespace blink {
 namespace {
 
-const char kTestData[] = "Here is sample text for the blob.";
+// const char kTestData[] = "Here is sample text for the blob.";
 
+/*
 class MockCanceller : public BodyStreamBuffer::Canceller {
 public:
     MockCanceller() : m_counter(0) { }
     void cancel() override { ++m_counter; }
     int counter() const { return m_counter; }
 
 private:
     int m_counter;
 };
+*/
 
 PassOwnPtr<WebServiceWorkerResponse> createTestWebServiceWorkerResponse()
 {
     const KURL url(ParsedURLString, "http://www.webresponse.com/");
     const unsigned short status = 200;
     const String statusText = "the best status text";
     struct {
         const char* key;
         const char* value;
     } headers[] = { { "cache-control", "no-cache" }, { "set-cookie", "foop" }, { "foo", "bar" }, { 0, 0 } };
@@ skipping 137 matching lines @@
     Response* response = Response::create(executionContext(), *webResponse);
 
     Headers* responseHeaders = response->headers();
     TrackExceptionState exceptionState;
     EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().data());
     EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data());
     EXPECT_STREQ("", responseHeaders->get("cache-control", exceptionState).utf8().data());
     EXPECT_FALSE(exceptionState.hadException());
 }
 
+/*
 void checkResponseBlobHandle(Response* response, bool hasNonInternalBlobHandle, const unsigned long long blobSize)
 {
     EXPECT_TRUE(response->internalBlobDataHandle());
     EXPECT_EQ(blobSize, response->internalBlobDataHandle()->size());
     EXPECT_FALSE(response->internalBuffer());
     if (hasNonInternalBlobHandle) {
         EXPECT_TRUE(response->blobDataHandle());
         EXPECT_EQ(response->blobDataHandle(), response->internalBlobDataHandle());
         EXPECT_EQ(blobSize, response->blobDataHandle()->size());
     } else {
@@ skipping 13 matching lines @@
     if (hasNonInternalBlobHandle) {
         EXPECT_EQ(response->internalBlobDataHandle(), response->blobDataHandle());
         EXPECT_EQ(clonedResponse->internalBlobDataHandle(), clonedResponse->blobDataHandle());
     } else {
         EXPECT_FALSE(response->blobDataHandle());
         EXPECT_FALSE(clonedResponse->blobDataHandle());
     }
     EXPECT_FALSE(response->buffer());
     EXPECT_FALSE(clonedResponse->buffer());
 }
+*/
 
+/*
 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneDefault)
 {
     FetchResponseData* fetchResponseData = FetchResponseData::create();
     fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com"));
     OwnPtr<BlobData> blobData(BlobData::create());
     blobData->appendBytes(kTestData, sizeof(kTestData) - 1);
     const unsigned long long size = blobData->length();
     fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release(), size));
     checkResponseBlobHandle(Response::create(executionContext(), fetchResponseData), true, size);
 }
@@ skipping 29 matching lines @@
     OwnPtr<BlobData> blobData(BlobData::create());
     blobData->appendBytes(kTestData, sizeof(kTestData) - 1);
     const unsigned long long size = blobData->length();
     fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release(), size));
     fetchResponseData = fetchResponseData->createOpaqueFilteredResponse();
     checkResponseBlobHandle(Response::create(executionContext(), fetchResponseData), false, size);
 }
 
 void checkResponseStream(Response* response, bool checkResponseBodyStreamBuffer)
 {
-    BodyStreamBuffer* buffer = response->internalBuffer();
-    EXPECT_FALSE(response->internalBlobDataHandle());
-    EXPECT_FALSE(response->blobDataHandle());
+    BodyStreamBuffer2* buffer = response->internalBuffer();
+    // EXPECT_FALSE(response->internalBlobDataHandle());
+    // EXPECT_FALSE(response->blobDataHandle());
     if (checkResponseBodyStreamBuffer) {
         EXPECT_EQ(response->buffer(), buffer);
     } else {
         EXPECT_FALSE(response->buffer());
     }
 
     TrackExceptionState exceptionState;
     Response* clonedResponse = response->clone(exceptionState);
     EXPECT_FALSE(exceptionState.hadException());
-    EXPECT_FALSE(response->internalBlobDataHandle());
-    EXPECT_FALSE(response->blobDataHandle());
-    EXPECT_FALSE(clonedResponse->internalBlobDataHandle());
-    EXPECT_FALSE(clonedResponse->blobDataHandle());
+    // EXPECT_FALSE(response->internalBlobDataHandle());
+    // EXPECT_FALSE(response->blobDataHandle());
+    // EXPECT_FALSE(clonedResponse->internalBlobDataHandle());
+    // EXPECT_FALSE(clonedResponse->blobDataHandle());
 
     EXPECT_TRUE(response->internalBuffer());
     EXPECT_TRUE(clonedResponse->internalBuffer());
     EXPECT_NE(response->internalBuffer(), buffer);
     EXPECT_NE(clonedResponse->internalBuffer(), buffer);
     EXPECT_NE(response->internalBuffer(), clonedResponse->internalBuffer());
     if (checkResponseBodyStreamBuffer) {
         EXPECT_EQ(response->buffer(), response->internalBuffer());
         EXPECT_EQ(clonedResponse->buffer(), clonedResponse->internalBuffer());
     } else {
@@ skipping 91 matching lines @@
     Response* response = Response::create(executionContext(), fetchResponseData);
     TrackExceptionState exceptionState;
     Response* clonedResponse = response->clone(exceptionState);
 
     EXPECT_EQ(0, canceller->counter());
     response->bufferForTest()->cancel();
     EXPECT_EQ(0, canceller->counter());
     clonedResponse->bufferForTest()->cancel();
     EXPECT_EQ(1, canceller->counter());
 }
+*/
 
 } // namespace
 } // namespace blink