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 "modules/fetch/BodyStreamBuffer.h" | 5 #include "modules/fetch/BodyStreamBuffer.h" |
6 | 6 |
| 7 #include "bindings/core/v8/V8BindingForTesting.h" |
7 #include "core/html/FormData.h" | 8 #include "core/html/FormData.h" |
8 #include "core/testing/DummyPageHolder.h" | |
9 #include "modules/fetch/DataConsumerHandleTestUtil.h" | 9 #include "modules/fetch/DataConsumerHandleTestUtil.h" |
10 #include "modules/fetch/FetchBlobDataConsumerHandle.h" | 10 #include "modules/fetch/FetchBlobDataConsumerHandle.h" |
11 #include "modules/fetch/FetchFormDataConsumerHandle.h" | 11 #include "modules/fetch/FetchFormDataConsumerHandle.h" |
12 #include "platform/blob/BlobData.h" | 12 #include "platform/blob/BlobData.h" |
13 #include "platform/blob/BlobURL.h" | 13 #include "platform/blob/BlobURL.h" |
14 #include "platform/network/EncodedFormData.h" | 14 #include "platform/network/EncodedFormData.h" |
15 #include "platform/testing/UnitTestHelpers.h" | 15 #include "platform/testing/UnitTestHelpers.h" |
16 #include "testing/gmock/include/gmock/gmock.h" | 16 #include "testing/gmock/include/gmock/gmock.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 17 #include "testing/gtest/include/gtest/gtest.h" |
18 #include "wtf/PtrUtil.h" | 18 #include "wtf/PtrUtil.h" |
(...skipping 14 matching lines...) Expand all Loading... |
33 class FakeLoaderFactory : public FetchBlobDataConsumerHandle::LoaderFactory { | 33 class FakeLoaderFactory : public FetchBlobDataConsumerHandle::LoaderFactory { |
34 public: | 34 public: |
35 std::unique_ptr<ThreadableLoader> create(ExecutionContext&, ThreadableLoader
Client*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&) override | 35 std::unique_ptr<ThreadableLoader> create(ExecutionContext&, ThreadableLoader
Client*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&) override |
36 { | 36 { |
37 ASSERT_NOT_REACHED(); | 37 ASSERT_NOT_REACHED(); |
38 return nullptr; | 38 return nullptr; |
39 } | 39 } |
40 }; | 40 }; |
41 | 41 |
42 class BodyStreamBufferTest : public ::testing::Test { | 42 class BodyStreamBufferTest : public ::testing::Test { |
43 public: | |
44 BodyStreamBufferTest() | |
45 { | |
46 m_page = DummyPageHolder::create(IntSize(1, 1)); | |
47 } | |
48 ~BodyStreamBufferTest() override {} | |
49 | |
50 protected: | 43 protected: |
51 ScriptState* getScriptState() { return ScriptState::forMainWorld(m_page->doc
ument().frame()); } | 44 ScriptValue eval(ScriptState* scriptState, const char* s) |
52 ExecutionContext* getExecutionContext() { return &m_page->document(); } | |
53 | |
54 std::unique_ptr<DummyPageHolder> m_page; | |
55 | |
56 ScriptValue eval(const char* s) | |
57 { | 45 { |
58 v8::Local<v8::String> source; | 46 v8::Local<v8::String> source; |
59 v8::Local<v8::Script> script; | 47 v8::Local<v8::Script> script; |
60 v8::MicrotasksScope microtasks(getScriptState()->isolate(), v8::Microtas
ksScope::kDoNotRunMicrotasks); | 48 v8::MicrotasksScope microtasks(scriptState->isolate(), v8::MicrotasksSco
pe::kDoNotRunMicrotasks); |
61 if (!v8Call(v8::String::NewFromUtf8(getScriptState()->isolate(), s, v8::
NewStringType::kNormal), source)) { | 49 if (!v8Call(v8::String::NewFromUtf8(scriptState->isolate(), s, v8::NewSt
ringType::kNormal), source)) { |
62 ADD_FAILURE(); | 50 ADD_FAILURE(); |
63 return ScriptValue(); | 51 return ScriptValue(); |
64 } | 52 } |
65 if (!v8Call(v8::Script::Compile(getScriptState()->context(), source), sc
ript)) { | 53 if (!v8Call(v8::Script::Compile(scriptState->context(), source), script)
) { |
66 ADD_FAILURE() << "Compilation fails"; | 54 ADD_FAILURE() << "Compilation fails"; |
67 return ScriptValue(); | 55 return ScriptValue(); |
68 } | 56 } |
69 return ScriptValue(getScriptState(), script->Run(getScriptState()->conte
xt())); | 57 return ScriptValue(scriptState, script->Run(scriptState->context())); |
70 } | 58 } |
71 ScriptValue evalWithPrintingError(const char* s) | 59 ScriptValue evalWithPrintingError(ScriptState* scriptState, const char* s) |
72 { | 60 { |
73 v8::TryCatch block(getScriptState()->isolate()); | 61 v8::TryCatch block(scriptState->isolate()); |
74 ScriptValue r = eval(s); | 62 ScriptValue r = eval(scriptState, s); |
75 if (block.HasCaught()) { | 63 if (block.HasCaught()) { |
76 ADD_FAILURE() << toCoreString(block.Exception()->ToString(getScriptS
tate()->isolate())).utf8().data(); | 64 ADD_FAILURE() << toCoreString(block.Exception()->ToString(scriptStat
e->isolate())).utf8().data(); |
77 block.ReThrow(); | 65 block.ReThrow(); |
78 } | 66 } |
79 return r; | 67 return r; |
80 } | 68 } |
81 }; | 69 }; |
82 | 70 |
83 TEST_F(BodyStreamBufferTest, Tee) | 71 TEST_F(BodyStreamBufferTest, Tee) |
84 { | 72 { |
| 73 V8TestingScope scope; |
85 Checkpoint checkpoint; | 74 Checkpoint checkpoint; |
86 MockFetchDataLoaderClient* client1 = MockFetchDataLoaderClient::create(); | 75 MockFetchDataLoaderClient* client1 = MockFetchDataLoaderClient::create(); |
87 MockFetchDataLoaderClient* client2 = MockFetchDataLoaderClient::create(); | 76 MockFetchDataLoaderClient* client2 = MockFetchDataLoaderClient::create(); |
88 | 77 |
89 InSequence s; | 78 InSequence s; |
90 EXPECT_CALL(checkpoint, Call(1)); | 79 EXPECT_CALL(checkpoint, Call(1)); |
91 EXPECT_CALL(*client1, didFetchDataLoadedString(String("hello, world"))); | 80 EXPECT_CALL(*client1, didFetchDataLoadedString(String("hello, world"))); |
92 EXPECT_CALL(checkpoint, Call(2)); | 81 EXPECT_CALL(checkpoint, Call(2)); |
93 EXPECT_CALL(checkpoint, Call(3)); | 82 EXPECT_CALL(checkpoint, Call(3)); |
94 EXPECT_CALL(*client2, didFetchDataLoadedString(String("hello, world"))); | 83 EXPECT_CALL(*client2, didFetchDataLoadedString(String("hello, world"))); |
95 EXPECT_CALL(checkpoint, Call(4)); | 84 EXPECT_CALL(checkpoint, Call(4)); |
96 | 85 |
97 std::unique_ptr<DataConsumerHandleTestUtil::ReplayingHandle> handle = DataCo
nsumerHandleTestUtil::ReplayingHandle::create(); | 86 std::unique_ptr<DataConsumerHandleTestUtil::ReplayingHandle> handle = DataCo
nsumerHandleTestUtil::ReplayingHandle::create(); |
98 handle->add(DataConsumerHandleTestUtil::Command(DataConsumerHandleTestUtil::
Command::Data, "hello, ")); | 87 handle->add(DataConsumerHandleTestUtil::Command(DataConsumerHandleTestUtil::
Command::Data, "hello, ")); |
99 handle->add(DataConsumerHandleTestUtil::Command(DataConsumerHandleTestUtil::
Command::Data, "world")); | 88 handle->add(DataConsumerHandleTestUtil::Command(DataConsumerHandleTestUtil::
Command::Data, "world")); |
100 handle->add(DataConsumerHandleTestUtil::Command(DataConsumerHandleTestUtil::
Command::Done)); | 89 handle->add(DataConsumerHandleTestUtil::Command(DataConsumerHandleTestUtil::
Command::Done)); |
101 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), createFetc
hDataConsumerHandleFromWebHandle(std::move(handle))); | 90 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), crea
teFetchDataConsumerHandleFromWebHandle(std::move(handle))); |
102 | 91 |
103 BodyStreamBuffer* new1; | 92 BodyStreamBuffer* new1; |
104 BodyStreamBuffer* new2; | 93 BodyStreamBuffer* new2; |
105 buffer->tee(&new1, &new2); | 94 buffer->tee(&new1, &new2); |
106 | 95 |
107 EXPECT_TRUE(buffer->isStreamLocked()); | 96 EXPECT_TRUE(buffer->isStreamLocked()); |
108 EXPECT_TRUE(buffer->isStreamDisturbed()); | 97 EXPECT_TRUE(buffer->isStreamDisturbed()); |
109 EXPECT_FALSE(buffer->hasPendingActivity()); | 98 EXPECT_FALSE(buffer->hasPendingActivity()); |
110 | 99 |
111 new1->startLoading(FetchDataLoader::createLoaderAsString(), client1); | 100 new1->startLoading(FetchDataLoader::createLoaderAsString(), client1); |
112 checkpoint.Call(1); | 101 checkpoint.Call(1); |
113 testing::runPendingTasks(); | 102 testing::runPendingTasks(); |
114 checkpoint.Call(2); | 103 checkpoint.Call(2); |
115 | 104 |
116 new2->startLoading(FetchDataLoader::createLoaderAsString(), client2); | 105 new2->startLoading(FetchDataLoader::createLoaderAsString(), client2); |
117 checkpoint.Call(3); | 106 checkpoint.Call(3); |
118 testing::runPendingTasks(); | 107 testing::runPendingTasks(); |
119 checkpoint.Call(4); | 108 checkpoint.Call(4); |
120 } | 109 } |
121 | 110 |
122 TEST_F(BodyStreamBufferTest, TeeFromHandleMadeFromStream) | 111 TEST_F(BodyStreamBufferTest, TeeFromHandleMadeFromStream) |
123 { | 112 { |
124 ScriptState::Scope scope(getScriptState()); | 113 V8TestingScope scope; |
125 ScriptValue stream = evalWithPrintingError( | 114 ScriptValue stream = evalWithPrintingError( |
| 115 scope.getScriptState(), |
126 "stream = new ReadableStream({start: c => controller = c});" | 116 "stream = new ReadableStream({start: c => controller = c});" |
127 "controller.enqueue(new Uint8Array([0x41, 0x42]));" | 117 "controller.enqueue(new Uint8Array([0x41, 0x42]));" |
128 "controller.enqueue(new Uint8Array([0x55, 0x58]));" | 118 "controller.enqueue(new Uint8Array([0x55, 0x58]));" |
129 "controller.close();" | 119 "controller.close();" |
130 "stream"); | 120 "stream"); |
131 Checkpoint checkpoint; | 121 Checkpoint checkpoint; |
132 MockFetchDataLoaderClient* client1 = MockFetchDataLoaderClient::create(); | 122 MockFetchDataLoaderClient* client1 = MockFetchDataLoaderClient::create(); |
133 MockFetchDataLoaderClient* client2 = MockFetchDataLoaderClient::create(); | 123 MockFetchDataLoaderClient* client2 = MockFetchDataLoaderClient::create(); |
134 | 124 |
135 InSequence s; | 125 InSequence s; |
136 EXPECT_CALL(checkpoint, Call(1)); | 126 EXPECT_CALL(checkpoint, Call(1)); |
137 EXPECT_CALL(*client1, didFetchDataLoadedString(String("ABUX"))); | 127 EXPECT_CALL(*client1, didFetchDataLoadedString(String("ABUX"))); |
138 EXPECT_CALL(checkpoint, Call(2)); | 128 EXPECT_CALL(checkpoint, Call(2)); |
139 EXPECT_CALL(checkpoint, Call(3)); | 129 EXPECT_CALL(checkpoint, Call(3)); |
140 EXPECT_CALL(*client2, didFetchDataLoadedString(String("ABUX"))); | 130 EXPECT_CALL(*client2, didFetchDataLoadedString(String("ABUX"))); |
141 EXPECT_CALL(checkpoint, Call(4)); | 131 EXPECT_CALL(checkpoint, Call(4)); |
142 | 132 |
143 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), stream); | 133 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), stre
am); |
144 | 134 |
145 BodyStreamBuffer* new1; | 135 BodyStreamBuffer* new1; |
146 BodyStreamBuffer* new2; | 136 BodyStreamBuffer* new2; |
147 buffer->tee(&new1, &new2); | 137 buffer->tee(&new1, &new2); |
148 | 138 |
149 EXPECT_TRUE(buffer->isStreamLocked()); | 139 EXPECT_TRUE(buffer->isStreamLocked()); |
150 // Note that this behavior is slightly different from for the behavior of | 140 // Note that this behavior is slightly different from for the behavior of |
151 // a BodyStreamBuffer made from a FetchDataConsumerHandle. See the above | 141 // a BodyStreamBuffer made from a FetchDataConsumerHandle. See the above |
152 // test. In this test, the stream will get disturbed when the microtask | 142 // test. In this test, the stream will get disturbed when the microtask |
153 // is performed. | 143 // is performed. |
154 // TODO(yhirano): A uniformed behavior is preferred. | 144 // TODO(yhirano): A uniformed behavior is preferred. |
155 EXPECT_FALSE(buffer->isStreamDisturbed()); | 145 EXPECT_FALSE(buffer->isStreamDisturbed()); |
156 EXPECT_FALSE(buffer->hasPendingActivity()); | 146 EXPECT_FALSE(buffer->hasPendingActivity()); |
157 | 147 |
158 v8::MicrotasksScope::PerformCheckpoint(getScriptState()->isolate()); | 148 v8::MicrotasksScope::PerformCheckpoint(scope.getScriptState()->isolate()); |
159 | 149 |
160 EXPECT_TRUE(buffer->isStreamLocked()); | 150 EXPECT_TRUE(buffer->isStreamLocked()); |
161 EXPECT_TRUE(buffer->isStreamDisturbed()); | 151 EXPECT_TRUE(buffer->isStreamDisturbed()); |
162 EXPECT_FALSE(buffer->hasPendingActivity()); | 152 EXPECT_FALSE(buffer->hasPendingActivity()); |
163 | 153 |
164 new1->startLoading(FetchDataLoader::createLoaderAsString(), client1); | 154 new1->startLoading(FetchDataLoader::createLoaderAsString(), client1); |
165 checkpoint.Call(1); | 155 checkpoint.Call(1); |
166 testing::runPendingTasks(); | 156 testing::runPendingTasks(); |
167 checkpoint.Call(2); | 157 checkpoint.Call(2); |
168 | 158 |
169 new2->startLoading(FetchDataLoader::createLoaderAsString(), client2); | 159 new2->startLoading(FetchDataLoader::createLoaderAsString(), client2); |
170 checkpoint.Call(3); | 160 checkpoint.Call(3); |
171 testing::runPendingTasks(); | 161 testing::runPendingTasks(); |
172 checkpoint.Call(4); | 162 checkpoint.Call(4); |
173 } | 163 } |
174 | 164 |
175 TEST_F(BodyStreamBufferTest, DrainAsBlobDataHandle) | 165 TEST_F(BodyStreamBufferTest, DrainAsBlobDataHandle) |
176 { | 166 { |
| 167 V8TestingScope scope; |
177 std::unique_ptr<BlobData> data = BlobData::create(); | 168 std::unique_ptr<BlobData> data = BlobData::create(); |
178 data->appendText("hello", false); | 169 data->appendText("hello", false); |
179 auto size = data->length(); | 170 auto size = data->length(); |
180 RefPtr<BlobDataHandle> blobDataHandle = BlobDataHandle::create(std::move(dat
a), size); | 171 RefPtr<BlobDataHandle> blobDataHandle = BlobDataHandle::create(std::move(dat
a), size); |
181 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), FetchBlobD
ataConsumerHandle::create(getExecutionContext(), blobDataHandle, new FakeLoaderF
actory)); | 172 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), Fetc
hBlobDataConsumerHandle::create(scope.getExecutionContext(), blobDataHandle, new
FakeLoaderFactory)); |
182 | 173 |
183 EXPECT_FALSE(buffer->isStreamLocked()); | 174 EXPECT_FALSE(buffer->isStreamLocked()); |
184 EXPECT_FALSE(buffer->isStreamDisturbed()); | 175 EXPECT_FALSE(buffer->isStreamDisturbed()); |
185 EXPECT_FALSE(buffer->hasPendingActivity()); | 176 EXPECT_FALSE(buffer->hasPendingActivity()); |
186 RefPtr<BlobDataHandle> outputBlobDataHandle = buffer->drainAsBlobDataHandle(
FetchDataConsumerHandle::Reader::AllowBlobWithInvalidSize); | 177 RefPtr<BlobDataHandle> outputBlobDataHandle = buffer->drainAsBlobDataHandle(
FetchDataConsumerHandle::Reader::AllowBlobWithInvalidSize); |
187 | 178 |
188 EXPECT_TRUE(buffer->isStreamLocked()); | 179 EXPECT_TRUE(buffer->isStreamLocked()); |
189 EXPECT_TRUE(buffer->isStreamDisturbed()); | 180 EXPECT_TRUE(buffer->isStreamDisturbed()); |
190 EXPECT_FALSE(buffer->hasPendingActivity()); | 181 EXPECT_FALSE(buffer->hasPendingActivity()); |
191 EXPECT_EQ(blobDataHandle, outputBlobDataHandle); | 182 EXPECT_EQ(blobDataHandle, outputBlobDataHandle); |
192 } | 183 } |
193 | 184 |
194 TEST_F(BodyStreamBufferTest, DrainAsBlobDataHandleReturnsNull) | 185 TEST_F(BodyStreamBufferTest, DrainAsBlobDataHandleReturnsNull) |
195 { | 186 { |
| 187 V8TestingScope scope; |
196 // This handle is not drainable. | 188 // This handle is not drainable. |
197 std::unique_ptr<FetchDataConsumerHandle> handle = createFetchDataConsumerHan
dleFromWebHandle(createWaitingDataConsumerHandle()); | 189 std::unique_ptr<FetchDataConsumerHandle> handle = createFetchDataConsumerHan
dleFromWebHandle(createWaitingDataConsumerHandle()); |
198 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), std::move(
handle)); | 190 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), std:
:move(handle)); |
199 | 191 |
200 EXPECT_FALSE(buffer->isStreamLocked()); | 192 EXPECT_FALSE(buffer->isStreamLocked()); |
201 EXPECT_FALSE(buffer->isStreamDisturbed()); | 193 EXPECT_FALSE(buffer->isStreamDisturbed()); |
202 EXPECT_FALSE(buffer->hasPendingActivity()); | 194 EXPECT_FALSE(buffer->hasPendingActivity()); |
203 | 195 |
204 EXPECT_FALSE(buffer->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::
AllowBlobWithInvalidSize)); | 196 EXPECT_FALSE(buffer->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::
AllowBlobWithInvalidSize)); |
205 | 197 |
206 EXPECT_FALSE(buffer->isStreamLocked()); | 198 EXPECT_FALSE(buffer->isStreamLocked()); |
207 EXPECT_FALSE(buffer->isStreamDisturbed()); | 199 EXPECT_FALSE(buffer->isStreamDisturbed()); |
208 EXPECT_FALSE(buffer->hasPendingActivity()); | 200 EXPECT_FALSE(buffer->hasPendingActivity()); |
209 } | 201 } |
210 | 202 |
211 TEST_F(BodyStreamBufferTest, DrainAsBlobFromBufferMadeFromBufferMadeFromStream) | 203 TEST_F(BodyStreamBufferTest, DrainAsBlobFromBufferMadeFromBufferMadeFromStream) |
212 { | 204 { |
213 ScriptState::Scope scope(getScriptState()); | 205 V8TestingScope scope; |
214 ScriptValue stream = evalWithPrintingError("new ReadableStream()"); | 206 ScriptValue stream = evalWithPrintingError(scope.getScriptState(), "new Read
ableStream()"); |
215 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), stream); | 207 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), stre
am); |
216 | 208 |
217 EXPECT_FALSE(buffer->hasPendingActivity()); | 209 EXPECT_FALSE(buffer->hasPendingActivity()); |
218 EXPECT_FALSE(buffer->isStreamLocked()); | 210 EXPECT_FALSE(buffer->isStreamLocked()); |
219 EXPECT_FALSE(buffer->isStreamDisturbed()); | 211 EXPECT_FALSE(buffer->isStreamDisturbed()); |
220 EXPECT_TRUE(buffer->isStreamReadable()); | 212 EXPECT_TRUE(buffer->isStreamReadable()); |
221 | 213 |
222 EXPECT_FALSE(buffer->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::
AllowBlobWithInvalidSize)); | 214 EXPECT_FALSE(buffer->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::
AllowBlobWithInvalidSize)); |
223 | 215 |
224 EXPECT_FALSE(buffer->hasPendingActivity()); | 216 EXPECT_FALSE(buffer->hasPendingActivity()); |
225 EXPECT_FALSE(buffer->isStreamLocked()); | 217 EXPECT_FALSE(buffer->isStreamLocked()); |
226 EXPECT_FALSE(buffer->isStreamDisturbed()); | 218 EXPECT_FALSE(buffer->isStreamDisturbed()); |
227 EXPECT_TRUE(buffer->isStreamReadable()); | 219 EXPECT_TRUE(buffer->isStreamReadable()); |
228 } | 220 } |
229 | 221 |
230 TEST_F(BodyStreamBufferTest, DrainAsFormData) | 222 TEST_F(BodyStreamBufferTest, DrainAsFormData) |
231 { | 223 { |
| 224 V8TestingScope scope; |
232 FormData* data = FormData::create(UTF8Encoding()); | 225 FormData* data = FormData::create(UTF8Encoding()); |
233 data->append("name1", "value1"); | 226 data->append("name1", "value1"); |
234 data->append("name2", "value2"); | 227 data->append("name2", "value2"); |
235 RefPtr<EncodedFormData> inputFormData = data->encodeMultiPartFormData(); | 228 RefPtr<EncodedFormData> inputFormData = data->encodeMultiPartFormData(); |
236 | 229 |
237 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), FetchFormD
ataConsumerHandle::create(getExecutionContext(), inputFormData)); | 230 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), Fetc
hFormDataConsumerHandle::create(scope.getExecutionContext(), inputFormData)); |
238 | 231 |
239 EXPECT_FALSE(buffer->isStreamLocked()); | 232 EXPECT_FALSE(buffer->isStreamLocked()); |
240 EXPECT_FALSE(buffer->isStreamDisturbed()); | 233 EXPECT_FALSE(buffer->isStreamDisturbed()); |
241 EXPECT_FALSE(buffer->hasPendingActivity()); | 234 EXPECT_FALSE(buffer->hasPendingActivity()); |
242 RefPtr<EncodedFormData> outputFormData = buffer->drainAsFormData(); | 235 RefPtr<EncodedFormData> outputFormData = buffer->drainAsFormData(); |
243 | 236 |
244 EXPECT_TRUE(buffer->isStreamLocked()); | 237 EXPECT_TRUE(buffer->isStreamLocked()); |
245 EXPECT_TRUE(buffer->isStreamDisturbed()); | 238 EXPECT_TRUE(buffer->isStreamDisturbed()); |
246 EXPECT_FALSE(buffer->hasPendingActivity()); | 239 EXPECT_FALSE(buffer->hasPendingActivity()); |
247 EXPECT_EQ(outputFormData->flattenToString(), inputFormData->flattenToString(
)); | 240 EXPECT_EQ(outputFormData->flattenToString(), inputFormData->flattenToString(
)); |
248 } | 241 } |
249 | 242 |
250 TEST_F(BodyStreamBufferTest, DrainAsFormDataReturnsNull) | 243 TEST_F(BodyStreamBufferTest, DrainAsFormDataReturnsNull) |
251 { | 244 { |
| 245 V8TestingScope scope; |
252 // This handle is not drainable. | 246 // This handle is not drainable. |
253 std::unique_ptr<FetchDataConsumerHandle> handle = createFetchDataConsumerHan
dleFromWebHandle(createWaitingDataConsumerHandle()); | 247 std::unique_ptr<FetchDataConsumerHandle> handle = createFetchDataConsumerHan
dleFromWebHandle(createWaitingDataConsumerHandle()); |
254 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), std::move(
handle)); | 248 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), std:
:move(handle)); |
255 | 249 |
256 EXPECT_FALSE(buffer->isStreamLocked()); | 250 EXPECT_FALSE(buffer->isStreamLocked()); |
257 EXPECT_FALSE(buffer->isStreamDisturbed()); | 251 EXPECT_FALSE(buffer->isStreamDisturbed()); |
258 EXPECT_FALSE(buffer->hasPendingActivity()); | 252 EXPECT_FALSE(buffer->hasPendingActivity()); |
259 | 253 |
260 EXPECT_FALSE(buffer->drainAsFormData()); | 254 EXPECT_FALSE(buffer->drainAsFormData()); |
261 | 255 |
262 EXPECT_FALSE(buffer->isStreamLocked()); | 256 EXPECT_FALSE(buffer->isStreamLocked()); |
263 EXPECT_FALSE(buffer->isStreamDisturbed()); | 257 EXPECT_FALSE(buffer->isStreamDisturbed()); |
264 EXPECT_FALSE(buffer->hasPendingActivity()); | 258 EXPECT_FALSE(buffer->hasPendingActivity()); |
265 } | 259 } |
266 | 260 |
267 TEST_F(BodyStreamBufferTest, DrainAsFormDataFromBufferMadeFromBufferMadeFromStre
am) | 261 TEST_F(BodyStreamBufferTest, DrainAsFormDataFromBufferMadeFromBufferMadeFromStre
am) |
268 { | 262 { |
269 ScriptState::Scope scope(getScriptState()); | 263 V8TestingScope scope; |
270 ScriptValue stream = evalWithPrintingError("new ReadableStream()"); | 264 ScriptValue stream = evalWithPrintingError(scope.getScriptState(), "new Read
ableStream()"); |
271 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), stream); | 265 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), stre
am); |
272 | 266 |
273 EXPECT_FALSE(buffer->hasPendingActivity()); | 267 EXPECT_FALSE(buffer->hasPendingActivity()); |
274 EXPECT_FALSE(buffer->isStreamLocked()); | 268 EXPECT_FALSE(buffer->isStreamLocked()); |
275 EXPECT_FALSE(buffer->isStreamDisturbed()); | 269 EXPECT_FALSE(buffer->isStreamDisturbed()); |
276 EXPECT_TRUE(buffer->isStreamReadable()); | 270 EXPECT_TRUE(buffer->isStreamReadable()); |
277 | 271 |
278 EXPECT_FALSE(buffer->drainAsFormData()); | 272 EXPECT_FALSE(buffer->drainAsFormData()); |
279 | 273 |
280 EXPECT_FALSE(buffer->hasPendingActivity()); | 274 EXPECT_FALSE(buffer->hasPendingActivity()); |
281 EXPECT_FALSE(buffer->isStreamLocked()); | 275 EXPECT_FALSE(buffer->isStreamLocked()); |
282 EXPECT_FALSE(buffer->isStreamDisturbed()); | 276 EXPECT_FALSE(buffer->isStreamDisturbed()); |
283 EXPECT_TRUE(buffer->isStreamReadable()); | 277 EXPECT_TRUE(buffer->isStreamReadable()); |
284 } | 278 } |
285 | 279 |
286 TEST_F(BodyStreamBufferTest, LoadBodyStreamBufferAsArrayBuffer) | 280 TEST_F(BodyStreamBufferTest, LoadBodyStreamBufferAsArrayBuffer) |
287 { | 281 { |
| 282 V8TestingScope scope; |
288 Checkpoint checkpoint; | 283 Checkpoint checkpoint; |
289 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); | 284 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); |
290 DOMArrayBuffer* arrayBuffer = nullptr; | 285 DOMArrayBuffer* arrayBuffer = nullptr; |
291 | 286 |
292 InSequence s; | 287 InSequence s; |
293 EXPECT_CALL(checkpoint, Call(1)); | 288 EXPECT_CALL(checkpoint, Call(1)); |
294 EXPECT_CALL(*client, didFetchDataLoadedArrayBufferMock(_)).WillOnce(SaveArg<
0>(&arrayBuffer)); | 289 EXPECT_CALL(*client, didFetchDataLoadedArrayBufferMock(_)).WillOnce(SaveArg<
0>(&arrayBuffer)); |
295 EXPECT_CALL(checkpoint, Call(2)); | 290 EXPECT_CALL(checkpoint, Call(2)); |
296 | 291 |
297 std::unique_ptr<ReplayingHandle> handle = ReplayingHandle::create(); | 292 std::unique_ptr<ReplayingHandle> handle = ReplayingHandle::create(); |
298 handle->add(Command(Command::Data, "hello")); | 293 handle->add(Command(Command::Data, "hello")); |
299 handle->add(Command(Command::Done)); | 294 handle->add(Command(Command::Done)); |
300 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), createFetc
hDataConsumerHandleFromWebHandle(std::move(handle))); | 295 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), crea
teFetchDataConsumerHandleFromWebHandle(std::move(handle))); |
301 buffer->startLoading(FetchDataLoader::createLoaderAsArrayBuffer(), client); | 296 buffer->startLoading(FetchDataLoader::createLoaderAsArrayBuffer(), client); |
302 | 297 |
303 EXPECT_TRUE(buffer->isStreamLocked()); | 298 EXPECT_TRUE(buffer->isStreamLocked()); |
304 EXPECT_TRUE(buffer->isStreamDisturbed()); | 299 EXPECT_TRUE(buffer->isStreamDisturbed()); |
305 EXPECT_TRUE(buffer->hasPendingActivity()); | 300 EXPECT_TRUE(buffer->hasPendingActivity()); |
306 | 301 |
307 checkpoint.Call(1); | 302 checkpoint.Call(1); |
308 testing::runPendingTasks(); | 303 testing::runPendingTasks(); |
309 checkpoint.Call(2); | 304 checkpoint.Call(2); |
310 | 305 |
311 EXPECT_TRUE(buffer->isStreamLocked()); | 306 EXPECT_TRUE(buffer->isStreamLocked()); |
312 EXPECT_TRUE(buffer->isStreamDisturbed()); | 307 EXPECT_TRUE(buffer->isStreamDisturbed()); |
313 EXPECT_FALSE(buffer->hasPendingActivity()); | 308 EXPECT_FALSE(buffer->hasPendingActivity()); |
314 ASSERT_TRUE(arrayBuffer); | 309 ASSERT_TRUE(arrayBuffer); |
315 EXPECT_EQ("hello", String(static_cast<const char*>(arrayBuffer->data()), arr
ayBuffer->byteLength())); | 310 EXPECT_EQ("hello", String(static_cast<const char*>(arrayBuffer->data()), arr
ayBuffer->byteLength())); |
316 } | 311 } |
317 | 312 |
318 TEST_F(BodyStreamBufferTest, LoadBodyStreamBufferAsBlob) | 313 TEST_F(BodyStreamBufferTest, LoadBodyStreamBufferAsBlob) |
319 { | 314 { |
| 315 V8TestingScope scope; |
320 Checkpoint checkpoint; | 316 Checkpoint checkpoint; |
321 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); | 317 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); |
322 RefPtr<BlobDataHandle> blobDataHandle; | 318 RefPtr<BlobDataHandle> blobDataHandle; |
323 | 319 |
324 InSequence s; | 320 InSequence s; |
325 EXPECT_CALL(checkpoint, Call(1)); | 321 EXPECT_CALL(checkpoint, Call(1)); |
326 EXPECT_CALL(*client, didFetchDataLoadedBlobHandleMock(_)).WillOnce(SaveArg<0
>(&blobDataHandle)); | 322 EXPECT_CALL(*client, didFetchDataLoadedBlobHandleMock(_)).WillOnce(SaveArg<0
>(&blobDataHandle)); |
327 EXPECT_CALL(checkpoint, Call(2)); | 323 EXPECT_CALL(checkpoint, Call(2)); |
328 | 324 |
329 std::unique_ptr<ReplayingHandle> handle = ReplayingHandle::create(); | 325 std::unique_ptr<ReplayingHandle> handle = ReplayingHandle::create(); |
330 handle->add(Command(Command::Data, "hello")); | 326 handle->add(Command(Command::Data, "hello")); |
331 handle->add(Command(Command::Done)); | 327 handle->add(Command(Command::Done)); |
332 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), createFetc
hDataConsumerHandleFromWebHandle(std::move(handle))); | 328 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), crea
teFetchDataConsumerHandleFromWebHandle(std::move(handle))); |
333 buffer->startLoading(FetchDataLoader::createLoaderAsBlobHandle("text/plain")
, client); | 329 buffer->startLoading(FetchDataLoader::createLoaderAsBlobHandle("text/plain")
, client); |
334 | 330 |
335 EXPECT_TRUE(buffer->isStreamLocked()); | 331 EXPECT_TRUE(buffer->isStreamLocked()); |
336 EXPECT_TRUE(buffer->isStreamDisturbed()); | 332 EXPECT_TRUE(buffer->isStreamDisturbed()); |
337 EXPECT_TRUE(buffer->hasPendingActivity()); | 333 EXPECT_TRUE(buffer->hasPendingActivity()); |
338 | 334 |
339 checkpoint.Call(1); | 335 checkpoint.Call(1); |
340 testing::runPendingTasks(); | 336 testing::runPendingTasks(); |
341 checkpoint.Call(2); | 337 checkpoint.Call(2); |
342 | 338 |
343 EXPECT_TRUE(buffer->isStreamLocked()); | 339 EXPECT_TRUE(buffer->isStreamLocked()); |
344 EXPECT_TRUE(buffer->isStreamDisturbed()); | 340 EXPECT_TRUE(buffer->isStreamDisturbed()); |
345 EXPECT_FALSE(buffer->hasPendingActivity()); | 341 EXPECT_FALSE(buffer->hasPendingActivity()); |
346 EXPECT_EQ(5u, blobDataHandle->size()); | 342 EXPECT_EQ(5u, blobDataHandle->size()); |
347 } | 343 } |
348 | 344 |
349 TEST_F(BodyStreamBufferTest, LoadBodyStreamBufferAsString) | 345 TEST_F(BodyStreamBufferTest, LoadBodyStreamBufferAsString) |
350 { | 346 { |
| 347 V8TestingScope scope; |
351 Checkpoint checkpoint; | 348 Checkpoint checkpoint; |
352 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); | 349 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); |
353 | 350 |
354 InSequence s; | 351 InSequence s; |
355 EXPECT_CALL(checkpoint, Call(1)); | 352 EXPECT_CALL(checkpoint, Call(1)); |
356 EXPECT_CALL(*client, didFetchDataLoadedString(String("hello"))); | 353 EXPECT_CALL(*client, didFetchDataLoadedString(String("hello"))); |
357 EXPECT_CALL(checkpoint, Call(2)); | 354 EXPECT_CALL(checkpoint, Call(2)); |
358 | 355 |
359 std::unique_ptr<ReplayingHandle> handle = ReplayingHandle::create(); | 356 std::unique_ptr<ReplayingHandle> handle = ReplayingHandle::create(); |
360 handle->add(Command(Command::Data, "hello")); | 357 handle->add(Command(Command::Data, "hello")); |
361 handle->add(Command(Command::Done)); | 358 handle->add(Command(Command::Done)); |
362 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), createFetc
hDataConsumerHandleFromWebHandle(std::move(handle))); | 359 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), crea
teFetchDataConsumerHandleFromWebHandle(std::move(handle))); |
363 buffer->startLoading(FetchDataLoader::createLoaderAsString(), client); | 360 buffer->startLoading(FetchDataLoader::createLoaderAsString(), client); |
364 | 361 |
365 EXPECT_TRUE(buffer->isStreamLocked()); | 362 EXPECT_TRUE(buffer->isStreamLocked()); |
366 EXPECT_TRUE(buffer->isStreamDisturbed()); | 363 EXPECT_TRUE(buffer->isStreamDisturbed()); |
367 EXPECT_TRUE(buffer->hasPendingActivity()); | 364 EXPECT_TRUE(buffer->hasPendingActivity()); |
368 | 365 |
369 checkpoint.Call(1); | 366 checkpoint.Call(1); |
370 testing::runPendingTasks(); | 367 testing::runPendingTasks(); |
371 checkpoint.Call(2); | 368 checkpoint.Call(2); |
372 | 369 |
373 EXPECT_TRUE(buffer->isStreamLocked()); | 370 EXPECT_TRUE(buffer->isStreamLocked()); |
374 EXPECT_TRUE(buffer->isStreamDisturbed()); | 371 EXPECT_TRUE(buffer->isStreamDisturbed()); |
375 EXPECT_FALSE(buffer->hasPendingActivity()); | 372 EXPECT_FALSE(buffer->hasPendingActivity()); |
376 } | 373 } |
377 | 374 |
378 TEST_F(BodyStreamBufferTest, LoadClosedHandle) | 375 TEST_F(BodyStreamBufferTest, LoadClosedHandle) |
379 { | 376 { |
| 377 V8TestingScope scope; |
380 Checkpoint checkpoint; | 378 Checkpoint checkpoint; |
381 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); | 379 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); |
382 | 380 |
383 InSequence s; | 381 InSequence s; |
384 EXPECT_CALL(checkpoint, Call(1)); | 382 EXPECT_CALL(checkpoint, Call(1)); |
385 EXPECT_CALL(*client, didFetchDataLoadedString(String(""))); | 383 EXPECT_CALL(*client, didFetchDataLoadedString(String(""))); |
386 EXPECT_CALL(checkpoint, Call(2)); | 384 EXPECT_CALL(checkpoint, Call(2)); |
387 | 385 |
388 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), createFetc
hDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle())); | 386 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), crea
teFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle())); |
389 | 387 |
390 EXPECT_TRUE(buffer->isStreamReadable()); | 388 EXPECT_TRUE(buffer->isStreamReadable()); |
391 testing::runPendingTasks(); | 389 testing::runPendingTasks(); |
392 EXPECT_TRUE(buffer->isStreamClosed()); | 390 EXPECT_TRUE(buffer->isStreamClosed()); |
393 | 391 |
394 EXPECT_FALSE(buffer->isStreamLocked()); | 392 EXPECT_FALSE(buffer->isStreamLocked()); |
395 EXPECT_FALSE(buffer->isStreamDisturbed()); | 393 EXPECT_FALSE(buffer->isStreamDisturbed()); |
396 EXPECT_FALSE(buffer->hasPendingActivity()); | 394 EXPECT_FALSE(buffer->hasPendingActivity()); |
397 | 395 |
398 buffer->startLoading(FetchDataLoader::createLoaderAsString(), client); | 396 buffer->startLoading(FetchDataLoader::createLoaderAsString(), client); |
399 EXPECT_TRUE(buffer->isStreamLocked()); | 397 EXPECT_TRUE(buffer->isStreamLocked()); |
400 EXPECT_TRUE(buffer->isStreamDisturbed()); | 398 EXPECT_TRUE(buffer->isStreamDisturbed()); |
401 EXPECT_TRUE(buffer->hasPendingActivity()); | 399 EXPECT_TRUE(buffer->hasPendingActivity()); |
402 | 400 |
403 checkpoint.Call(1); | 401 checkpoint.Call(1); |
404 testing::runPendingTasks(); | 402 testing::runPendingTasks(); |
405 checkpoint.Call(2); | 403 checkpoint.Call(2); |
406 | 404 |
407 EXPECT_TRUE(buffer->isStreamLocked()); | 405 EXPECT_TRUE(buffer->isStreamLocked()); |
408 EXPECT_TRUE(buffer->isStreamDisturbed()); | 406 EXPECT_TRUE(buffer->isStreamDisturbed()); |
409 EXPECT_FALSE(buffer->hasPendingActivity()); | 407 EXPECT_FALSE(buffer->hasPendingActivity()); |
410 } | 408 } |
411 | 409 |
412 TEST_F(BodyStreamBufferTest, LoadErroredHandle) | 410 TEST_F(BodyStreamBufferTest, LoadErroredHandle) |
413 { | 411 { |
| 412 V8TestingScope scope; |
414 Checkpoint checkpoint; | 413 Checkpoint checkpoint; |
415 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); | 414 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); |
416 | 415 |
417 InSequence s; | 416 InSequence s; |
418 EXPECT_CALL(checkpoint, Call(1)); | 417 EXPECT_CALL(checkpoint, Call(1)); |
419 EXPECT_CALL(*client, didFetchDataLoadFailed()); | 418 EXPECT_CALL(*client, didFetchDataLoadFailed()); |
420 EXPECT_CALL(checkpoint, Call(2)); | 419 EXPECT_CALL(checkpoint, Call(2)); |
421 | 420 |
422 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), createFetc
hDataConsumerHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle())); | 421 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), crea
teFetchDataConsumerHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle()
)); |
423 | 422 |
424 EXPECT_TRUE(buffer->isStreamReadable()); | 423 EXPECT_TRUE(buffer->isStreamReadable()); |
425 testing::runPendingTasks(); | 424 testing::runPendingTasks(); |
426 EXPECT_TRUE(buffer->isStreamErrored()); | 425 EXPECT_TRUE(buffer->isStreamErrored()); |
427 | 426 |
428 EXPECT_FALSE(buffer->isStreamLocked()); | 427 EXPECT_FALSE(buffer->isStreamLocked()); |
429 EXPECT_FALSE(buffer->isStreamDisturbed()); | 428 EXPECT_FALSE(buffer->isStreamDisturbed()); |
430 EXPECT_FALSE(buffer->hasPendingActivity()); | 429 EXPECT_FALSE(buffer->hasPendingActivity()); |
431 buffer->startLoading(FetchDataLoader::createLoaderAsString(), client); | 430 buffer->startLoading(FetchDataLoader::createLoaderAsString(), client); |
432 EXPECT_TRUE(buffer->isStreamLocked()); | 431 EXPECT_TRUE(buffer->isStreamLocked()); |
433 EXPECT_TRUE(buffer->isStreamDisturbed()); | 432 EXPECT_TRUE(buffer->isStreamDisturbed()); |
434 EXPECT_TRUE(buffer->hasPendingActivity()); | 433 EXPECT_TRUE(buffer->hasPendingActivity()); |
435 | 434 |
436 checkpoint.Call(1); | 435 checkpoint.Call(1); |
437 testing::runPendingTasks(); | 436 testing::runPendingTasks(); |
438 checkpoint.Call(2); | 437 checkpoint.Call(2); |
439 | 438 |
440 EXPECT_TRUE(buffer->isStreamLocked()); | 439 EXPECT_TRUE(buffer->isStreamLocked()); |
441 EXPECT_TRUE(buffer->isStreamDisturbed()); | 440 EXPECT_TRUE(buffer->isStreamDisturbed()); |
442 EXPECT_FALSE(buffer->hasPendingActivity()); | 441 EXPECT_FALSE(buffer->hasPendingActivity()); |
443 } | 442 } |
444 | 443 |
445 TEST_F(BodyStreamBufferTest, LoaderShouldBeKeptAliveByBodyStreamBuffer) | 444 TEST_F(BodyStreamBufferTest, LoaderShouldBeKeptAliveByBodyStreamBuffer) |
446 { | 445 { |
| 446 V8TestingScope scope; |
447 Checkpoint checkpoint; | 447 Checkpoint checkpoint; |
448 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); | 448 MockFetchDataLoaderClient* client = MockFetchDataLoaderClient::create(); |
449 | 449 |
450 InSequence s; | 450 InSequence s; |
451 EXPECT_CALL(checkpoint, Call(1)); | 451 EXPECT_CALL(checkpoint, Call(1)); |
452 EXPECT_CALL(*client, didFetchDataLoadedString(String("hello"))); | 452 EXPECT_CALL(*client, didFetchDataLoadedString(String("hello"))); |
453 EXPECT_CALL(checkpoint, Call(2)); | 453 EXPECT_CALL(checkpoint, Call(2)); |
454 | 454 |
455 std::unique_ptr<ReplayingHandle> handle = ReplayingHandle::create(); | 455 std::unique_ptr<ReplayingHandle> handle = ReplayingHandle::create(); |
456 handle->add(Command(Command::Data, "hello")); | 456 handle->add(Command(Command::Data, "hello")); |
457 handle->add(Command(Command::Done)); | 457 handle->add(Command(Command::Done)); |
458 Persistent<BodyStreamBuffer> buffer = new BodyStreamBuffer(getScriptState(),
createFetchDataConsumerHandleFromWebHandle(std::move(handle))); | 458 Persistent<BodyStreamBuffer> buffer = new BodyStreamBuffer(scope.getScriptSt
ate(), createFetchDataConsumerHandleFromWebHandle(std::move(handle))); |
459 buffer->startLoading(FetchDataLoader::createLoaderAsString(), client); | 459 buffer->startLoading(FetchDataLoader::createLoaderAsString(), client); |
460 | 460 |
461 ThreadHeap::collectAllGarbage(); | 461 ThreadHeap::collectAllGarbage(); |
462 checkpoint.Call(1); | 462 checkpoint.Call(1); |
463 testing::runPendingTasks(); | 463 testing::runPendingTasks(); |
464 checkpoint.Call(2); | 464 checkpoint.Call(2); |
465 } | 465 } |
466 | 466 |
467 // TODO(hiroshige): Merge this class into MockFetchDataConsumerHandle. | 467 // TODO(hiroshige): Merge this class into MockFetchDataConsumerHandle. |
468 class MockFetchDataConsumerHandleWithMockDestructor : public DataConsumerHandleT
estUtil::MockFetchDataConsumerHandle { | 468 class MockFetchDataConsumerHandleWithMockDestructor : public DataConsumerHandleT
estUtil::MockFetchDataConsumerHandle { |
469 public: | 469 public: |
470 static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerHandleWith
MockDestructor>> create() { return wrapUnique(new ::testing::StrictMock<MockFetc
hDataConsumerHandleWithMockDestructor>); } | 470 static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerHandleWith
MockDestructor>> create() { return wrapUnique(new ::testing::StrictMock<MockFetc
hDataConsumerHandleWithMockDestructor>); } |
471 | 471 |
472 ~MockFetchDataConsumerHandleWithMockDestructor() override | 472 ~MockFetchDataConsumerHandleWithMockDestructor() override |
473 { | 473 { |
474 destruct(); | 474 destruct(); |
475 } | 475 } |
476 | 476 |
477 MOCK_METHOD0(destruct, void()); | 477 MOCK_METHOD0(destruct, void()); |
478 }; | 478 }; |
479 | 479 |
480 TEST_F(BodyStreamBufferTest, SourceHandleAndReaderShouldBeDestructedWhenCanceled
) | 480 TEST_F(BodyStreamBufferTest, SourceHandleAndReaderShouldBeDestructedWhenCanceled
) |
481 { | 481 { |
482 ScriptState::Scope scope(getScriptState()); | 482 V8TestingScope scope; |
483 using MockHandle = MockFetchDataConsumerHandleWithMockDestructor; | 483 using MockHandle = MockFetchDataConsumerHandleWithMockDestructor; |
484 using MockReader = DataConsumerHandleTestUtil::MockFetchDataConsumerReader; | 484 using MockReader = DataConsumerHandleTestUtil::MockFetchDataConsumerReader; |
485 std::unique_ptr<MockHandle> handle = MockHandle::create(); | 485 std::unique_ptr<MockHandle> handle = MockHandle::create(); |
486 std::unique_ptr<MockReader> reader = MockReader::create(); | 486 std::unique_ptr<MockReader> reader = MockReader::create(); |
487 | 487 |
488 Checkpoint checkpoint; | 488 Checkpoint checkpoint; |
489 InSequence s; | 489 InSequence s; |
490 | 490 |
491 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(::testing::Return(rea
der.get())); | 491 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(::testing::Return(rea
der.get())); |
492 EXPECT_CALL(checkpoint, Call(1)); | 492 EXPECT_CALL(checkpoint, Call(1)); |
493 EXPECT_CALL(*reader, destruct()); | 493 EXPECT_CALL(*reader, destruct()); |
494 EXPECT_CALL(*handle, destruct()); | 494 EXPECT_CALL(*handle, destruct()); |
495 EXPECT_CALL(checkpoint, Call(2)); | 495 EXPECT_CALL(checkpoint, Call(2)); |
496 | 496 |
497 // |reader| is adopted by |obtainReader|. | 497 // |reader| is adopted by |obtainReader|. |
498 ASSERT_TRUE(reader.release()); | 498 ASSERT_TRUE(reader.release()); |
499 | 499 |
500 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), std::move(
handle)); | 500 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), std:
:move(handle)); |
501 checkpoint.Call(1); | 501 checkpoint.Call(1); |
502 ScriptValue reason(getScriptState(), v8String(getScriptState()->isolate(), "
reason")); | 502 ScriptValue reason(scope.getScriptState(), v8String(scope.getScriptState()->
isolate(), "reason")); |
503 buffer->cancelSource(getScriptState(), reason); | 503 buffer->cancelSource(scope.getScriptState(), reason); |
504 checkpoint.Call(2); | 504 checkpoint.Call(2); |
505 } | 505 } |
506 | 506 |
507 } // namespace | 507 } // namespace |
508 | 508 |
509 } // namespace blink | 509 } // namespace blink |
OLD | NEW |