| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "config.h" | |
| 6 #include "modules/serviceworkers/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 void trace(Visitor* visitor) override | |
| 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 virtual void trace(Visitor* visitor) override | |
| 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(PassRefPtrWillBeRawPtr<DOMException> exception) overrid
e | |
| 64 { | |
| 65 m_exception = exception; | |
| 66 } | |
| 67 PassRefPtr<BlobDataHandle> blobHandle() | |
| 68 { | |
| 69 return m_blobHandle; | |
| 70 } | |
| 71 PassRefPtrWillBeRawPtr<DOMException> exception() | |
| 72 { | |
| 73 return m_exception; | |
| 74 } | |
| 75 | |
| 76 private: | |
| 77 RefPtr<BlobDataHandle> m_blobHandle; | |
| 78 RefPtrWillBeMember<DOMException> m_exception; | |
| 79 }; | |
| 80 | |
| 81 } // namespace | |
| 82 | |
| 83 TEST(BodyStreamBufferTest, Read) | |
| 84 { | |
| 85 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
| 86 RefPtr<DOMArrayBuffer> arrayBuffer1 = DOMArrayBuffer::create("foobar", 6); | |
| 87 RefPtr<DOMArrayBuffer> arrayBuffer2 = DOMArrayBuffer::create("abc", 3); | |
| 88 RefPtr<DOMArrayBuffer> arrayBuffer3 = DOMArrayBuffer::create("piyo", 4); | |
| 89 buffer->write(arrayBuffer1); | |
| 90 buffer->write(arrayBuffer2); | |
| 91 EXPECT_EQ(arrayBuffer1, buffer->read()); | |
| 92 EXPECT_EQ(arrayBuffer2, buffer->read()); | |
| 93 EXPECT_FALSE(buffer->read()); | |
| 94 buffer->write(arrayBuffer3); | |
| 95 EXPECT_EQ(arrayBuffer3, buffer->read()); | |
| 96 EXPECT_FALSE(buffer->read()); | |
| 97 } | |
| 98 | |
| 99 TEST(BodyStreamBufferTest, Exception) | |
| 100 { | |
| 101 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
| 102 EXPECT_FALSE(buffer->exception()); | |
| 103 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
| 104 EXPECT_TRUE(buffer->exception()); | |
| 105 EXPECT_EQ("NetworkError", buffer->exception()->name()); | |
| 106 EXPECT_EQ("Error Message", buffer->exception()->message()); | |
| 107 } | |
| 108 | |
| 109 TEST(BodyStreamBufferTest, Observer) | |
| 110 { | |
| 111 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
| 112 MockObserver* observer1 = new MockObserver(); | |
| 113 MockObserver* observer2 = new MockObserver(); | |
| 114 EXPECT_TRUE(buffer->registerObserver(observer1)); | |
| 115 EXPECT_FALSE(buffer->registerObserver(observer2)); | |
| 116 EXPECT_EQ(0, observer1->writeCount()); | |
| 117 EXPECT_EQ(0, observer1->closeCount()); | |
| 118 EXPECT_EQ(0, observer1->errorCount()); | |
| 119 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 120 EXPECT_EQ(1, observer1->writeCount()); | |
| 121 EXPECT_EQ(0, observer1->closeCount()); | |
| 122 EXPECT_EQ(0, observer1->errorCount()); | |
| 123 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
| 124 EXPECT_EQ(2, observer1->writeCount()); | |
| 125 EXPECT_EQ(0, observer1->closeCount()); | |
| 126 EXPECT_EQ(0, observer1->errorCount()); | |
| 127 EXPECT_FALSE(buffer->isClosed()); | |
| 128 buffer->close(); | |
| 129 EXPECT_TRUE(buffer->isClosed()); | |
| 130 EXPECT_EQ(2, observer1->writeCount()); | |
| 131 EXPECT_EQ(1, observer1->closeCount()); | |
| 132 EXPECT_EQ(0, observer1->errorCount()); | |
| 133 EXPECT_EQ(0, observer2->writeCount()); | |
| 134 EXPECT_EQ(0, observer2->closeCount()); | |
| 135 EXPECT_EQ(0, observer2->errorCount()); | |
| 136 } | |
| 137 | |
| 138 TEST(BodyStreamBufferTest, CreateBlob) | |
| 139 { | |
| 140 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
| 141 BlobHandleCallback* callback1 = new BlobHandleCallback(); | |
| 142 BlobHandleCallback* callback2 = new BlobHandleCallback(); | |
| 143 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("text/html", callback1)); | |
| 144 EXPECT_FALSE(buffer->readAllAndCreateBlobHandle("text/html", callback2)); | |
| 145 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 146 EXPECT_FALSE(callback1->blobHandle()); | |
| 147 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
| 148 EXPECT_FALSE(callback1->blobHandle()); | |
| 149 buffer->close(); | |
| 150 EXPECT_TRUE(callback1->blobHandle()); | |
| 151 EXPECT_EQ("text/html", callback1->blobHandle()->type()); | |
| 152 EXPECT_FALSE(callback2->blobHandle()); | |
| 153 EXPECT_EQ(10u, callback1->blobHandle()->size()); | |
| 154 WebVector<WebBlobData::Item*> items; | |
| 155 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback1->
blobHandle()->uuid(), &items)); | |
| 156 EXPECT_EQ(2u, items.size()); | |
| 157 EXPECT_EQ(6u, items[0]->data.size()); | |
| 158 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobar", 6)); | |
| 159 EXPECT_EQ(4u, items[1]->data.size()); | |
| 160 EXPECT_EQ(0, memcmp(items[1]->data.data(), "piyo", 4)); | |
| 161 EXPECT_FALSE(callback1->exception()); | |
| 162 EXPECT_FALSE(callback2->exception()); | |
| 163 } | |
| 164 | |
| 165 TEST(BodyStreamBufferTest, CreateBlobAfterWrite) | |
| 166 { | |
| 167 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
| 168 BlobHandleCallback* callback = new BlobHandleCallback(); | |
| 169 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 170 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
| 171 buffer->close(); | |
| 172 EXPECT_TRUE(callback->blobHandle()); | |
| 173 EXPECT_EQ(6u, callback->blobHandle()->size()); | |
| 174 WebVector<WebBlobData::Item*> items; | |
| 175 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback->b
lobHandle()->uuid(), &items)); | |
| 176 EXPECT_EQ(1u, items.size()); | |
| 177 EXPECT_EQ(6u, items[0]->data.size()); | |
| 178 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobar", 6)); | |
| 179 } | |
| 180 | |
| 181 TEST(BodyStreamBufferTest, CreateBlobAfterClose) | |
| 182 { | |
| 183 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
| 184 BlobHandleCallback* callback = new BlobHandleCallback(); | |
| 185 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 186 buffer->close(); | |
| 187 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
| 188 EXPECT_TRUE(callback->blobHandle()); | |
| 189 EXPECT_EQ(6u, callback->blobHandle()->size()); | |
| 190 WebVector<WebBlobData::Item*> items; | |
| 191 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback->b
lobHandle()->uuid(), &items)); | |
| 192 EXPECT_EQ(1u, items.size()); | |
| 193 EXPECT_EQ(6u, items[0]->data.size()); | |
| 194 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobar", 6)); | |
| 195 } | |
| 196 | |
| 197 TEST(BodyStreamBufferTest, CreateBlobException) | |
| 198 { | |
| 199 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
| 200 BlobHandleCallback* callback1 = new BlobHandleCallback(); | |
| 201 BlobHandleCallback* callback2 = new BlobHandleCallback(); | |
| 202 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback1)); | |
| 203 EXPECT_FALSE(buffer->readAllAndCreateBlobHandle("", callback2)); | |
| 204 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 205 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
| 206 EXPECT_FALSE(buffer->hasError()); | |
| 207 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
| 208 EXPECT_TRUE(buffer->hasError()); | |
| 209 EXPECT_FALSE(callback1->blobHandle()); | |
| 210 EXPECT_FALSE(callback2->blobHandle()); | |
| 211 EXPECT_TRUE(callback1->exception()); | |
| 212 EXPECT_FALSE(callback2->exception()); | |
| 213 EXPECT_EQ("NetworkError", callback1->exception()->name()); | |
| 214 EXPECT_EQ("Error Message", callback1->exception()->message()); | |
| 215 } | |
| 216 | |
| 217 TEST(BodyStreamBufferTest, CreateBlobExceptionAfterWrite) | |
| 218 { | |
| 219 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
| 220 BlobHandleCallback* callback = new BlobHandleCallback(); | |
| 221 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 222 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
| 223 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
| 224 EXPECT_TRUE(callback->exception()); | |
| 225 EXPECT_EQ("NetworkError", callback->exception()->name()); | |
| 226 EXPECT_EQ("Error Message", callback->exception()->message()); | |
| 227 } | |
| 228 | |
| 229 TEST(BodyStreamBufferTest, CreateBlobExceptionAfterError) | |
| 230 { | |
| 231 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
| 232 BlobHandleCallback* callback = new BlobHandleCallback(); | |
| 233 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
| 234 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
| 235 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
| 236 EXPECT_TRUE(callback->exception()); | |
| 237 EXPECT_EQ("NetworkError", callback->exception()->name()); | |
| 238 EXPECT_EQ("Error Message", callback->exception()->message()); | |
| 239 } | |
| 240 | |
| 241 } // namespace blink | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 795323003:
Move Fetch API releted code to modules/fetch. (Closed)
Base URL: https://chromium.googlesource.com/chromium/blink.git@master