| OLD | NEW |
|---|
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 #include "config.h" | 5 // TODO(hiroshige): re-add unit tests. |
| 6 #include "modules/fetch/BodyStreamBuffer.h" | |
| 7 | |
| 8 #include "core/dom/DOMArrayBuffer.h" | |
| 9 #include "core/dom/DOMException.h" | |
| 10 #include "core/dom/ExceptionCode.h" | |
| 11 #include "platform/heap/Heap.h" | |
| 12 #include "public/platform/Platform.h" | |
| 13 #include "public/platform/WebUnitTestSupport.h" | |
| 14 #include "public/platform/WebVector.h" | |
| 15 #include "wtf/RefPtr.h" | |
| 16 #include "wtf/testing/WTFTestHelpers.h" | |
| 17 #include <gtest/gtest.h> | |
| 18 | |
| 19 namespace blink { | |
| 20 namespace { | |
| 21 | |
| 22 class MockObserver final : public BodyStreamBuffer::Observer { | |
| 23 public: | |
| 24 MockObserver() | |
| 25 : m_writeCount(0) | |
| 26 , m_closeCount(0) | |
| 27 , m_errorCount(0) | |
| 28 { | |
| 29 } | |
| 30 ~MockObserver() override { } | |
| 31 DEFINE_INLINE_VIRTUAL_TRACE() | |
| 32 { | |
| 33 BodyStreamBuffer::Observer::trace(visitor); | |
| 34 } | |
| 35 void onWrite() override { ++m_writeCount; } | |
| 36 void onClose() override { ++m_closeCount; } | |
| 37 void onError() override { ++m_errorCount; } | |
| 38 int writeCount() const { return m_writeCount; } | |
| 39 int closeCount() const { return m_closeCount; } | |
| 40 int errorCount() const { return m_errorCount; } | |
| 41 | |
| 42 private: | |
| 43 int m_writeCount; | |
| 44 int m_closeCount; | |
| 45 int m_errorCount; | |
| 46 }; | |
| 47 | |
| 48 class BlobHandleCallback final : public BodyStreamBuffer::BlobHandleCreatorClien
t { | |
| 49 public: | |
| 50 BlobHandleCallback() | |
| 51 { | |
| 52 } | |
| 53 virtual ~BlobHandleCallback() override { } | |
| 54 DEFINE_INLINE_VIRTUAL_TRACE() | |
| 55 { | |
| 56 visitor->trace(m_exception); | |
| 57 BodyStreamBuffer::BlobHandleCreatorClient::trace(visitor); | |
| 58 } | |
| 59 virtual void didCreateBlobHandle(PassRefPtr<BlobDataHandle> blobHandle) over
ride | |
| 60 { | |
| 61 m_blobHandle = blobHandle; | |
| 62 } | |
| 63 virtual void didFail(DOMException* exception) override | |
| 64 { | |
| 65 m_exception = exception; | |
| 66 } | |
| 67 PassRefPtr<BlobDataHandle> blobHandle() | |
| 68 { | |
| 69 return m_blobHandle; | |
| 70 } | |
| 71 DOMException* exception() | |
| 72 { | |
| 73 return m_exception; | |
| 74 } | |
| 75 | |
| 76 private: | |
| 77 RefPtr<BlobDataHandle> m_blobHandle; | |
| 78 Member<DOMException> m_exception; | |
| 79 }; | |
| 80 | |
| 81 class MockCanceller : public BodyStreamBuffer::Canceller { | |
| 82 public: | |
| 83 MockCanceller() : m_counter(0) { } | |
| 84 void cancel() override { ++m_counter; } | |
| 85 int counter() const { return m_counter; } | |
| 86 | |
| 87 private: | |
| 88 int m_counter; | |
| 89 }; | |
| 90 | |
| 91 } // namespace | |
| 92 | |
| 93 TEST(BodyStreamBufferTest, Read) | |
| 94 { | |
| 95 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
| 96 RefPtr<DOMArrayBuffer> arrayBuffer1 = DOMArrayBuffer::create("foobar", 6); | |
| 97 RefPtr<DOMArrayBuffer> arrayBuffer2 = DOMArrayBuffer::create("abc", 3); | |
| 98 RefPtr<DOMArrayBuffer> arrayBuffer3 = DOMArrayBuffer::create("piyo", 4); | |
| 99 buffer->write(arrayBuffer1); | |
| 100 buffer->write(arrayBuffer2); | |
| 101 EXPECT_EQ(arrayBuffer1, buffer->read()); | |
| 102 EXPECT_EQ(arrayBuffer2, buffer->read()); | |
| 103 EXPECT_FALSE(buffer->read()); | |
| 104 buffer->write(arrayBuffer3); | |
| 105 EXPECT_EQ(arrayBuffer3, buffer->read()); | |
| 106 EXPECT_FALSE(buffer->read()); | |
| 107 } | |
| 108 | |
| 109 TEST(BodyStreamBufferTest, Exception) | |
| 110 { | |
| 111 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
| 112 EXPECT_FALSE(buffer->exception()); | |
| 113 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
| 114 EXPECT_TRUE(buffer->exception()); | |
| 115 EXPECT_EQ("NetworkError", buffer->exception()->name()); | |
| 116 EXPECT_EQ("Error Message", buffer->exception()->message()); | |
| 117 } | |
| 118 | |
| 119 TEST(BodyStreamBufferTest, Observer) | |
| 120 { | |
| 121 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
| 122 MockObserver* observer1 = new MockObserver(); | |
| 123 MockObserver* observer2 = new MockObserver(); | |
| 124 EXPECT_TRUE(buffer->registerObserver(observer1)); | |
| 125 EXPECT_FALSE(buffer->registerObserver(observer2)); | |
| 126 EXPECT_EQ(0, observer1->writeCount()); | |
| 127 EXPECT_EQ(0, observer1->closeCount()); | |
| 128 EXPECT_EQ(0, observer1->errorCount()); | |
| 129 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 130 EXPECT_EQ(1, observer1->writeCount()); | |
| 131 EXPECT_EQ(0, observer1->closeCount()); | |
| 132 EXPECT_EQ(0, observer1->errorCount()); | |
| 133 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
| 134 EXPECT_EQ(2, observer1->writeCount()); | |
| 135 EXPECT_EQ(0, observer1->closeCount()); | |
| 136 EXPECT_EQ(0, observer1->errorCount()); | |
| 137 EXPECT_FALSE(buffer->isClosed()); | |
| 138 buffer->close(); | |
| 139 EXPECT_TRUE(buffer->isClosed()); | |
| 140 EXPECT_EQ(2, observer1->writeCount()); | |
| 141 EXPECT_EQ(1, observer1->closeCount()); | |
| 142 EXPECT_EQ(0, observer1->errorCount()); | |
| 143 EXPECT_EQ(0, observer2->writeCount()); | |
| 144 EXPECT_EQ(0, observer2->closeCount()); | |
| 145 EXPECT_EQ(0, observer2->errorCount()); | |
| 146 } | |
| 147 | |
| 148 TEST(BodyStreamBufferTest, CreateBlob) | |
| 149 { | |
| 150 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
| 151 BlobHandleCallback* callback1 = new BlobHandleCallback(); | |
| 152 BlobHandleCallback* callback2 = new BlobHandleCallback(); | |
| 153 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("text/html", callback1)); | |
| 154 EXPECT_FALSE(buffer->readAllAndCreateBlobHandle("text/html", callback2)); | |
| 155 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 156 EXPECT_FALSE(callback1->blobHandle()); | |
| 157 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
| 158 EXPECT_FALSE(callback1->blobHandle()); | |
| 159 buffer->close(); | |
| 160 EXPECT_TRUE(callback1->blobHandle()); | |
| 161 EXPECT_EQ("text/html", callback1->blobHandle()->type()); | |
| 162 EXPECT_FALSE(callback2->blobHandle()); | |
| 163 EXPECT_EQ(10u, callback1->blobHandle()->size()); | |
| 164 WebVector<WebBlobData::Item*> items; | |
| 165 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback1->
blobHandle()->uuid(), &items)); | |
| 166 // The data has been consolidated. | |
| 167 EXPECT_EQ(1u, items.size()); | |
| 168 EXPECT_EQ(10u, items[0]->data.size()); | |
| 169 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobarpiyo", 10)); | |
| 170 EXPECT_FALSE(callback1->exception()); | |
| 171 EXPECT_FALSE(callback2->exception()); | |
| 172 } | |
| 173 | |
| 174 TEST(BodyStreamBufferTest, CreateBlobAfterWrite) | |
| 175 { | |
| 176 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
| 177 BlobHandleCallback* callback = new BlobHandleCallback(); | |
| 178 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 179 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
| 180 buffer->close(); | |
| 181 EXPECT_TRUE(callback->blobHandle()); | |
| 182 EXPECT_EQ(6u, callback->blobHandle()->size()); | |
| 183 WebVector<WebBlobData::Item*> items; | |
| 184 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback->b
lobHandle()->uuid(), &items)); | |
| 185 EXPECT_EQ(1u, items.size()); | |
| 186 EXPECT_EQ(6u, items[0]->data.size()); | |
| 187 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobar", 6)); | |
| 188 } | |
| 189 | |
| 190 TEST(BodyStreamBufferTest, CreateBlobAfterClose) | |
| 191 { | |
| 192 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
| 193 BlobHandleCallback* callback = new BlobHandleCallback(); | |
| 194 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 195 buffer->close(); | |
| 196 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
| 197 EXPECT_TRUE(callback->blobHandle()); | |
| 198 EXPECT_EQ(6u, callback->blobHandle()->size()); | |
| 199 WebVector<WebBlobData::Item*> items; | |
| 200 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback->b
lobHandle()->uuid(), &items)); | |
| 201 EXPECT_EQ(1u, items.size()); | |
| 202 EXPECT_EQ(6u, items[0]->data.size()); | |
| 203 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobar", 6)); | |
| 204 } | |
| 205 | |
| 206 TEST(BodyStreamBufferTest, CreateBlobException) | |
| 207 { | |
| 208 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
| 209 BlobHandleCallback* callback1 = new BlobHandleCallback(); | |
| 210 BlobHandleCallback* callback2 = new BlobHandleCallback(); | |
| 211 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback1)); | |
| 212 EXPECT_FALSE(buffer->readAllAndCreateBlobHandle("", callback2)); | |
| 213 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 214 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
| 215 EXPECT_FALSE(buffer->hasError()); | |
| 216 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
| 217 EXPECT_TRUE(buffer->hasError()); | |
| 218 EXPECT_FALSE(callback1->blobHandle()); | |
| 219 EXPECT_FALSE(callback2->blobHandle()); | |
| 220 EXPECT_TRUE(callback1->exception()); | |
| 221 EXPECT_FALSE(callback2->exception()); | |
| 222 EXPECT_EQ("NetworkError", callback1->exception()->name()); | |
| 223 EXPECT_EQ("Error Message", callback1->exception()->message()); | |
| 224 } | |
| 225 | |
| 226 TEST(BodyStreamBufferTest, CreateBlobExceptionAfterWrite) | |
| 227 { | |
| 228 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
| 229 BlobHandleCallback* callback = new BlobHandleCallback(); | |
| 230 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 231 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
| 232 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
| 233 EXPECT_TRUE(callback->exception()); | |
| 234 EXPECT_EQ("NetworkError", callback->exception()->name()); | |
| 235 EXPECT_EQ("Error Message", callback->exception()->message()); | |
| 236 } | |
| 237 | |
| 238 TEST(BodyStreamBufferTest, CreateBlobExceptionAfterError) | |
| 239 { | |
| 240 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
| 241 BlobHandleCallback* callback = new BlobHandleCallback(); | |
| 242 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 243 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
| 244 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
| 245 EXPECT_TRUE(callback->exception()); | |
| 246 EXPECT_EQ("NetworkError", callback->exception()->name()); | |
| 247 EXPECT_EQ("Error Message", callback->exception()->message()); | |
| 248 } | |
| 249 | |
| 250 TEST(BodyStreamBufferTest, Cancel) | |
| 251 { | |
| 252 auto canceller = new MockCanceller; | |
| 253 BodyStreamBuffer* buffer = new BodyStreamBuffer(canceller); | |
| 254 buffer->cancel(); | |
| 255 | |
| 256 EXPECT_EQ(1, canceller->counter()); | |
| 257 EXPECT_FALSE(buffer->isClosed()); | |
| 258 EXPECT_FALSE(buffer->hasError()); | |
| 259 } | |
| 260 | |
| 261 } // namespace blink | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1192913007:
Change BodyStreamBuffer to be FetchDataConsumerHandle-based and enable backpressure in Fetch API (Closed)
Base URL: https://chromium.googlesource.com/chromium/blink.git@master