OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "android_webview/browser/net/android_stream_reader_url_request_job.h" | 5 #include "android_webview/browser/net/android_stream_reader_url_request_job.h" |
6 | 6 |
| 7 #include <memory> |
7 #include <utility> | 8 #include <utility> |
8 | 9 |
9 #include "android_webview/browser/input_stream.h" | 10 #include "android_webview/browser/input_stream.h" |
10 #include "android_webview/browser/net/aw_url_request_job_factory.h" | 11 #include "android_webview/browser/net/aw_url_request_job_factory.h" |
11 #include "android_webview/browser/net/input_stream_reader.h" | 12 #include "android_webview/browser/net/input_stream_reader.h" |
12 #include "base/format_macros.h" | 13 #include "base/format_macros.h" |
13 #include "base/memory/scoped_ptr.h" | 14 #include "base/memory/ptr_util.h" |
14 #include "base/run_loop.h" | 15 #include "base/run_loop.h" |
15 #include "base/single_thread_task_runner.h" | 16 #include "base/single_thread_task_runner.h" |
16 #include "base/strings/stringprintf.h" | 17 #include "base/strings/stringprintf.h" |
17 #include "base/thread_task_runner_handle.h" | 18 #include "base/thread_task_runner_handle.h" |
18 #include "net/base/request_priority.h" | 19 #include "net/base/request_priority.h" |
19 #include "net/http/http_byte_range.h" | 20 #include "net/http/http_byte_range.h" |
20 #include "net/http/http_response_headers.h" | 21 #include "net/http/http_response_headers.h" |
21 #include "net/url_request/url_request.h" | 22 #include "net/url_request/url_request.h" |
22 #include "net/url_request/url_request_job_factory_impl.h" | 23 #include "net/url_request/url_request_job_factory_impl.h" |
23 #include "net/url_request/url_request_test_util.h" | 24 #include "net/url_request/url_request_test_util.h" |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
70 return false; | 71 return false; |
71 } | 72 } |
72 }; | 73 }; |
73 | 74 |
74 // Required in order to create an instance of AndroidStreamReaderURLRequestJob. | 75 // Required in order to create an instance of AndroidStreamReaderURLRequestJob. |
75 class StreamReaderDelegate : | 76 class StreamReaderDelegate : |
76 public AndroidStreamReaderURLRequestJob::Delegate { | 77 public AndroidStreamReaderURLRequestJob::Delegate { |
77 public: | 78 public: |
78 StreamReaderDelegate() {} | 79 StreamReaderDelegate() {} |
79 | 80 |
80 scoped_ptr<InputStream> OpenInputStream(JNIEnv* env, | 81 std::unique_ptr<InputStream> OpenInputStream(JNIEnv* env, |
81 const GURL& url) override { | 82 const GURL& url) override { |
82 return make_scoped_ptr<InputStream>(new NotImplInputStream()); | 83 return base::WrapUnique(new NotImplInputStream()); |
83 } | 84 } |
84 | 85 |
85 void OnInputStreamOpenFailed(net::URLRequest* request, | 86 void OnInputStreamOpenFailed(net::URLRequest* request, |
86 bool* restart) override { | 87 bool* restart) override { |
87 *restart = false; | 88 *restart = false; |
88 } | 89 } |
89 | 90 |
90 bool GetMimeType(JNIEnv* env, | 91 bool GetMimeType(JNIEnv* env, |
91 net::URLRequest* request, | 92 net::URLRequest* request, |
92 android_webview::InputStream* stream, | 93 android_webview::InputStream* stream, |
(...skipping 11 matching lines...) Expand all Loading... |
104 void AppendResponseHeaders(JNIEnv* env, | 105 void AppendResponseHeaders(JNIEnv* env, |
105 net::HttpResponseHeaders* headers) override { | 106 net::HttpResponseHeaders* headers) override { |
106 // no-op | 107 // no-op |
107 } | 108 } |
108 }; | 109 }; |
109 | 110 |
110 class NullStreamReaderDelegate : public StreamReaderDelegate { | 111 class NullStreamReaderDelegate : public StreamReaderDelegate { |
111 public: | 112 public: |
112 NullStreamReaderDelegate() {} | 113 NullStreamReaderDelegate() {} |
113 | 114 |
114 scoped_ptr<InputStream> OpenInputStream(JNIEnv* env, | 115 std::unique_ptr<InputStream> OpenInputStream(JNIEnv* env, |
115 const GURL& url) override { | 116 const GURL& url) override { |
116 return make_scoped_ptr<InputStream>(NULL); | 117 return nullptr; |
117 } | 118 } |
118 }; | 119 }; |
119 | 120 |
120 class HeaderAlteringStreamReaderDelegate : public NullStreamReaderDelegate { | 121 class HeaderAlteringStreamReaderDelegate : public NullStreamReaderDelegate { |
121 public: | 122 public: |
122 HeaderAlteringStreamReaderDelegate() {} | 123 HeaderAlteringStreamReaderDelegate() {} |
123 | 124 |
124 void AppendResponseHeaders(JNIEnv* env, | 125 void AppendResponseHeaders(JNIEnv* env, |
125 net::HttpResponseHeaders* headers) override { | 126 net::HttpResponseHeaders* headers) override { |
126 headers->ReplaceStatusLine(kStatusLine); | 127 headers->ReplaceStatusLine(kStatusLine); |
(...skipping 24 matching lines...) Expand all Loading... |
151 | 152 |
152 MOCK_METHOD1(Seek, int(const net::HttpByteRange& byte_range)); | 153 MOCK_METHOD1(Seek, int(const net::HttpByteRange& byte_range)); |
153 MOCK_METHOD2(ReadRawData, int(net::IOBuffer* buffer, int buffer_size)); | 154 MOCK_METHOD2(ReadRawData, int(net::IOBuffer* buffer, int buffer_size)); |
154 }; | 155 }; |
155 | 156 |
156 | 157 |
157 class TestStreamReaderJob : public AndroidStreamReaderURLRequestJob { | 158 class TestStreamReaderJob : public AndroidStreamReaderURLRequestJob { |
158 public: | 159 public: |
159 TestStreamReaderJob(net::URLRequest* request, | 160 TestStreamReaderJob(net::URLRequest* request, |
160 net::NetworkDelegate* network_delegate, | 161 net::NetworkDelegate* network_delegate, |
161 scoped_ptr<Delegate> delegate, | 162 std::unique_ptr<Delegate> delegate, |
162 scoped_ptr<InputStreamReader> stream_reader) | 163 std::unique_ptr<InputStreamReader> stream_reader) |
163 : AndroidStreamReaderURLRequestJob(request, | 164 : AndroidStreamReaderURLRequestJob(request, |
164 network_delegate, | 165 network_delegate, |
165 std::move(delegate)), | 166 std::move(delegate)), |
166 stream_reader_(std::move(stream_reader)) { | 167 stream_reader_(std::move(stream_reader)) { |
167 task_runner_ = base::ThreadTaskRunnerHandle::Get(); | 168 task_runner_ = base::ThreadTaskRunnerHandle::Get(); |
168 } | 169 } |
169 | 170 |
170 ~TestStreamReaderJob() override {} | 171 ~TestStreamReaderJob() override {} |
171 | 172 |
172 scoped_ptr<InputStreamReader> CreateStreamReader( | 173 std::unique_ptr<InputStreamReader> CreateStreamReader( |
173 InputStream* stream) override { | 174 InputStream* stream) override { |
174 return std::move(stream_reader_); | 175 return std::move(stream_reader_); |
175 } | 176 } |
176 | 177 |
177 protected: | 178 protected: |
178 base::TaskRunner* GetWorkerThreadRunner() override { | 179 base::TaskRunner* GetWorkerThreadRunner() override { |
179 return task_runner_.get(); | 180 return task_runner_.get(); |
180 } | 181 } |
181 | 182 |
182 scoped_ptr<InputStreamReader> stream_reader_; | 183 std::unique_ptr<InputStreamReader> stream_reader_; |
183 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; | 184 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; |
184 }; | 185 }; |
185 | 186 |
186 } // namespace | 187 } // namespace |
187 | 188 |
188 | 189 |
189 class AndroidStreamReaderURLRequestJobTest : public Test { | 190 class AndroidStreamReaderURLRequestJobTest : public Test { |
190 public: | 191 public: |
191 AndroidStreamReaderURLRequestJobTest() {} | 192 AndroidStreamReaderURLRequestJobTest() {} |
192 | 193 |
193 protected: | 194 protected: |
194 void SetUp() override { | 195 void SetUp() override { |
195 context_.set_job_factory(&factory_); | 196 context_.set_job_factory(&factory_); |
196 context_.set_network_delegate(&network_delegate_); | 197 context_.set_network_delegate(&network_delegate_); |
197 req_ = context_.CreateRequest(GURL("content://foo"), | 198 req_ = context_.CreateRequest(GURL("content://foo"), |
198 net::DEFAULT_PRIORITY, | 199 net::DEFAULT_PRIORITY, |
199 &url_request_delegate_); | 200 &url_request_delegate_); |
200 req_->set_method("GET"); | 201 req_->set_method("GET"); |
201 } | 202 } |
202 | 203 |
203 void SetRange(net::URLRequest* req, int first_byte, int last_byte) { | 204 void SetRange(net::URLRequest* req, int first_byte, int last_byte) { |
204 net::HttpRequestHeaders headers; | 205 net::HttpRequestHeaders headers; |
205 headers.SetHeader(net::HttpRequestHeaders::kRange, | 206 headers.SetHeader(net::HttpRequestHeaders::kRange, |
206 net::HttpByteRange::Bounded( | 207 net::HttpByteRange::Bounded( |
207 first_byte, last_byte).GetHeaderValue()); | 208 first_byte, last_byte).GetHeaderValue()); |
208 req->SetExtraRequestHeaders(headers); | 209 req->SetExtraRequestHeaders(headers); |
209 } | 210 } |
210 | 211 |
211 void SetUpTestJob(scoped_ptr<InputStreamReader> stream_reader) { | 212 void SetUpTestJob(std::unique_ptr<InputStreamReader> stream_reader) { |
212 SetUpTestJob(std::move(stream_reader), | 213 SetUpTestJob(std::move(stream_reader), |
213 make_scoped_ptr(new StreamReaderDelegate())); | 214 base::WrapUnique(new StreamReaderDelegate())); |
214 } | 215 } |
215 | 216 |
216 void SetUpTestJob(scoped_ptr<InputStreamReader> stream_reader, | 217 void SetUpTestJob(std::unique_ptr<InputStreamReader> stream_reader, |
217 scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate> | 218 std::unique_ptr<AndroidStreamReaderURLRequestJob::Delegate> |
218 stream_reader_delegate) { | 219 stream_reader_delegate) { |
219 scoped_ptr<TestStreamReaderJob> test_stream_reader_job( | 220 std::unique_ptr<TestStreamReaderJob> test_stream_reader_job( |
220 new TestStreamReaderJob(req_.get(), &network_delegate_, | 221 new TestStreamReaderJob(req_.get(), &network_delegate_, |
221 std::move(stream_reader_delegate), | 222 std::move(stream_reader_delegate), |
222 std::move(stream_reader))); | 223 std::move(stream_reader))); |
223 // The Interceptor is owned by the |factory_|. | 224 // The Interceptor is owned by the |factory_|. |
224 scoped_ptr<TestJobInterceptor> protocol_handler(new TestJobInterceptor); | 225 std::unique_ptr<TestJobInterceptor> protocol_handler( |
| 226 new TestJobInterceptor); |
225 protocol_handler->set_main_intercept_job(std::move(test_stream_reader_job)); | 227 protocol_handler->set_main_intercept_job(std::move(test_stream_reader_job)); |
226 bool set_protocol = | 228 bool set_protocol = |
227 factory_.SetProtocolHandler("content", std::move(protocol_handler)); | 229 factory_.SetProtocolHandler("content", std::move(protocol_handler)); |
228 DCHECK(set_protocol); | 230 DCHECK(set_protocol); |
229 } | 231 } |
230 | 232 |
231 base::MessageLoopForIO loop_; | 233 base::MessageLoopForIO loop_; |
232 TestURLRequestContext context_; | 234 TestURLRequestContext context_; |
233 android_webview::AwURLRequestJobFactory factory_; | 235 android_webview::AwURLRequestJobFactory factory_; |
234 TestDelegate url_request_delegate_; | 236 TestDelegate url_request_delegate_; |
235 TestNetworkDelegate network_delegate_; | 237 TestNetworkDelegate network_delegate_; |
236 scoped_ptr<URLRequest> req_; | 238 std::unique_ptr<URLRequest> req_; |
237 }; | 239 }; |
238 | 240 |
239 TEST_F(AndroidStreamReaderURLRequestJobTest, ReadEmptyStream) { | 241 TEST_F(AndroidStreamReaderURLRequestJobTest, ReadEmptyStream) { |
240 scoped_ptr<StrictMock<MockInputStreamReader> > stream_reader( | 242 std::unique_ptr<StrictMock<MockInputStreamReader>> stream_reader( |
241 new StrictMock<MockInputStreamReader>()); | 243 new StrictMock<MockInputStreamReader>()); |
242 { | 244 { |
243 InSequence s; | 245 InSequence s; |
244 EXPECT_CALL(*stream_reader, Seek(_)) | 246 EXPECT_CALL(*stream_reader, Seek(_)) |
245 .WillOnce(Return(0)); | 247 .WillOnce(Return(0)); |
246 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Gt(0))) | 248 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Gt(0))) |
247 .WillOnce(Return(0)); | 249 .WillOnce(Return(0)); |
248 } | 250 } |
249 | 251 |
250 SetUpTestJob(std::move(stream_reader)); | 252 SetUpTestJob(std::move(stream_reader)); |
251 | 253 |
252 req_->Start(); | 254 req_->Start(); |
253 | 255 |
254 // The TestDelegate will quit the message loop on request completion. | 256 // The TestDelegate will quit the message loop on request completion. |
255 base::MessageLoop::current()->Run(); | 257 base::MessageLoop::current()->Run(); |
256 | 258 |
257 EXPECT_FALSE(url_request_delegate_.request_failed()); | 259 EXPECT_FALSE(url_request_delegate_.request_failed()); |
258 EXPECT_EQ(1, network_delegate_.completed_requests()); | 260 EXPECT_EQ(1, network_delegate_.completed_requests()); |
259 EXPECT_EQ(0, network_delegate_.error_count()); | 261 EXPECT_EQ(0, network_delegate_.error_count()); |
260 EXPECT_EQ(200, req_->GetResponseCode()); | 262 EXPECT_EQ(200, req_->GetResponseCode()); |
261 } | 263 } |
262 | 264 |
263 TEST_F(AndroidStreamReaderURLRequestJobTest, ReadWithNullStream) { | 265 TEST_F(AndroidStreamReaderURLRequestJobTest, ReadWithNullStream) { |
264 SetUpTestJob(nullptr, make_scoped_ptr(new NullStreamReaderDelegate())); | 266 SetUpTestJob(nullptr, base::WrapUnique(new NullStreamReaderDelegate())); |
265 req_->Start(); | 267 req_->Start(); |
266 | 268 |
267 // The TestDelegate will quit the message loop on request completion. | 269 // The TestDelegate will quit the message loop on request completion. |
268 base::MessageLoop::current()->Run(); | 270 base::MessageLoop::current()->Run(); |
269 | 271 |
270 // The request_failed() method is named confusingly but all it checks is | 272 // The request_failed() method is named confusingly but all it checks is |
271 // whether the request got as far as calling NotifyHeadersComplete. | 273 // whether the request got as far as calling NotifyHeadersComplete. |
272 EXPECT_FALSE(url_request_delegate_.request_failed()); | 274 EXPECT_FALSE(url_request_delegate_.request_failed()); |
273 EXPECT_EQ(1, network_delegate_.completed_requests()); | 275 EXPECT_EQ(1, network_delegate_.completed_requests()); |
274 // A null input stream shouldn't result in an error. See crbug.com/180950. | 276 // A null input stream shouldn't result in an error. See crbug.com/180950. |
275 EXPECT_EQ(0, network_delegate_.error_count()); | 277 EXPECT_EQ(0, network_delegate_.error_count()); |
276 EXPECT_EQ(404, req_->GetResponseCode()); | 278 EXPECT_EQ(404, req_->GetResponseCode()); |
277 } | 279 } |
278 | 280 |
279 TEST_F(AndroidStreamReaderURLRequestJobTest, ModifyHeadersAndStatus) { | 281 TEST_F(AndroidStreamReaderURLRequestJobTest, ModifyHeadersAndStatus) { |
280 SetUpTestJob(nullptr, | 282 SetUpTestJob(nullptr, |
281 make_scoped_ptr(new HeaderAlteringStreamReaderDelegate())); | 283 base::WrapUnique(new HeaderAlteringStreamReaderDelegate())); |
282 req_->Start(); | 284 req_->Start(); |
283 | 285 |
284 // The TestDelegate will quit the message loop on request completion. | 286 // The TestDelegate will quit the message loop on request completion. |
285 base::MessageLoop::current()->Run(); | 287 base::MessageLoop::current()->Run(); |
286 | 288 |
287 // The request_failed() method is named confusingly but all it checks is | 289 // The request_failed() method is named confusingly but all it checks is |
288 // whether the request got as far as calling NotifyHeadersComplete. | 290 // whether the request got as far as calling NotifyHeadersComplete. |
289 EXPECT_FALSE(url_request_delegate_.request_failed()); | 291 EXPECT_FALSE(url_request_delegate_.request_failed()); |
290 EXPECT_EQ(1, network_delegate_.completed_requests()); | 292 EXPECT_EQ(1, network_delegate_.completed_requests()); |
291 // A null input stream shouldn't result in an error. See crbug.com/180950. | 293 // A null input stream shouldn't result in an error. See crbug.com/180950. |
292 EXPECT_EQ(0, network_delegate_.error_count()); | 294 EXPECT_EQ(0, network_delegate_.error_count()); |
293 EXPECT_EQ(HeaderAlteringStreamReaderDelegate::kResponseCode, | 295 EXPECT_EQ(HeaderAlteringStreamReaderDelegate::kResponseCode, |
294 req_->GetResponseCode()); | 296 req_->GetResponseCode()); |
295 EXPECT_EQ(HeaderAlteringStreamReaderDelegate::kStatusLine, | 297 EXPECT_EQ(HeaderAlteringStreamReaderDelegate::kStatusLine, |
296 req_->response_headers()->GetStatusLine()); | 298 req_->response_headers()->GetStatusLine()); |
297 EXPECT_TRUE(req_->response_headers()->HasHeader( | 299 EXPECT_TRUE(req_->response_headers()->HasHeader( |
298 HeaderAlteringStreamReaderDelegate::kCustomHeaderName)); | 300 HeaderAlteringStreamReaderDelegate::kCustomHeaderName)); |
299 std::string header_value; | 301 std::string header_value; |
300 EXPECT_TRUE(req_->response_headers()->EnumerateHeader( | 302 EXPECT_TRUE(req_->response_headers()->EnumerateHeader( |
301 NULL, HeaderAlteringStreamReaderDelegate::kCustomHeaderName, | 303 NULL, HeaderAlteringStreamReaderDelegate::kCustomHeaderName, |
302 &header_value)); | 304 &header_value)); |
303 EXPECT_EQ(HeaderAlteringStreamReaderDelegate::kCustomHeaderValue, | 305 EXPECT_EQ(HeaderAlteringStreamReaderDelegate::kCustomHeaderValue, |
304 header_value); | 306 header_value); |
305 } | 307 } |
306 | 308 |
307 TEST_F(AndroidStreamReaderURLRequestJobTest, ReadPartOfStream) { | 309 TEST_F(AndroidStreamReaderURLRequestJobTest, ReadPartOfStream) { |
308 const int bytes_available = 128; | 310 const int bytes_available = 128; |
309 const int offset = 32; | 311 const int offset = 32; |
310 const int bytes_to_read = bytes_available - offset; | 312 const int bytes_to_read = bytes_available - offset; |
311 scoped_ptr<StrictMock<MockInputStreamReader> > stream_reader( | 313 std::unique_ptr<StrictMock<MockInputStreamReader>> stream_reader( |
312 new StrictMock<MockInputStreamReader>()); | 314 new StrictMock<MockInputStreamReader>()); |
313 { | 315 { |
314 InSequence s; | 316 InSequence s; |
315 EXPECT_CALL(*stream_reader, Seek(_)) | 317 EXPECT_CALL(*stream_reader, Seek(_)) |
316 .WillOnce(Return(bytes_available)); | 318 .WillOnce(Return(bytes_available)); |
317 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read))) | 319 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read))) |
318 .WillOnce(Return(bytes_to_read/2)); | 320 .WillOnce(Return(bytes_to_read/2)); |
319 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read))) | 321 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read))) |
320 .WillOnce(Return(bytes_to_read/2)); | 322 .WillOnce(Return(bytes_to_read/2)); |
321 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read))) | 323 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read))) |
(...skipping 12 matching lines...) Expand all Loading... |
334 EXPECT_EQ(1, network_delegate_.completed_requests()); | 336 EXPECT_EQ(1, network_delegate_.completed_requests()); |
335 EXPECT_EQ(0, network_delegate_.error_count()); | 337 EXPECT_EQ(0, network_delegate_.error_count()); |
336 } | 338 } |
337 | 339 |
338 TEST_F(AndroidStreamReaderURLRequestJobTest, | 340 TEST_F(AndroidStreamReaderURLRequestJobTest, |
339 ReadStreamWithMoreAvailableThanActual) { | 341 ReadStreamWithMoreAvailableThanActual) { |
340 const int bytes_available_reported = 190; | 342 const int bytes_available_reported = 190; |
341 const int bytes_available = 128; | 343 const int bytes_available = 128; |
342 const int offset = 0; | 344 const int offset = 0; |
343 const int bytes_to_read = bytes_available - offset; | 345 const int bytes_to_read = bytes_available - offset; |
344 scoped_ptr<StrictMock<MockInputStreamReader> > stream_reader( | 346 std::unique_ptr<StrictMock<MockInputStreamReader>> stream_reader( |
345 new StrictMock<MockInputStreamReader>()); | 347 new StrictMock<MockInputStreamReader>()); |
346 { | 348 { |
347 InSequence s; | 349 InSequence s; |
348 EXPECT_CALL(*stream_reader, Seek(_)) | 350 EXPECT_CALL(*stream_reader, Seek(_)) |
349 .WillOnce(Return(bytes_available_reported)); | 351 .WillOnce(Return(bytes_available_reported)); |
350 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read))) | 352 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read))) |
351 .WillOnce(Return(bytes_available)); | 353 .WillOnce(Return(bytes_available)); |
352 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read))) | 354 EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read))) |
353 .WillOnce(Return(0)); | 355 .WillOnce(Return(0)); |
354 } | 356 } |
355 | 357 |
356 SetUpTestJob(std::move(stream_reader)); | 358 SetUpTestJob(std::move(stream_reader)); |
357 | 359 |
358 SetRange(req_.get(), offset, bytes_available_reported); | 360 SetRange(req_.get(), offset, bytes_available_reported); |
359 req_->Start(); | 361 req_->Start(); |
360 | 362 |
361 base::MessageLoop::current()->Run(); | 363 base::MessageLoop::current()->Run(); |
362 | 364 |
363 EXPECT_FALSE(url_request_delegate_.request_failed()); | 365 EXPECT_FALSE(url_request_delegate_.request_failed()); |
364 EXPECT_EQ(bytes_to_read, url_request_delegate_.bytes_received()); | 366 EXPECT_EQ(bytes_to_read, url_request_delegate_.bytes_received()); |
365 EXPECT_EQ(1, network_delegate_.completed_requests()); | 367 EXPECT_EQ(1, network_delegate_.completed_requests()); |
366 EXPECT_EQ(0, network_delegate_.error_count()); | 368 EXPECT_EQ(0, network_delegate_.error_count()); |
367 } | 369 } |
368 | 370 |
369 TEST_F(AndroidStreamReaderURLRequestJobTest, DeleteJobMidWaySeek) { | 371 TEST_F(AndroidStreamReaderURLRequestJobTest, DeleteJobMidWaySeek) { |
370 const int offset = 20; | 372 const int offset = 20; |
371 const int bytes_available = 128; | 373 const int bytes_available = 128; |
372 base::RunLoop loop; | 374 base::RunLoop loop; |
373 scoped_ptr<StrictMock<MockInputStreamReader> > stream_reader( | 375 std::unique_ptr<StrictMock<MockInputStreamReader>> stream_reader( |
374 new StrictMock<MockInputStreamReader>()); | 376 new StrictMock<MockInputStreamReader>()); |
375 EXPECT_CALL(*stream_reader, Seek(_)) | 377 EXPECT_CALL(*stream_reader, Seek(_)) |
376 .WillOnce(DoAll(InvokeWithoutArgs(&loop, &base::RunLoop::Quit), | 378 .WillOnce(DoAll(InvokeWithoutArgs(&loop, &base::RunLoop::Quit), |
377 Return(bytes_available))); | 379 Return(bytes_available))); |
378 ON_CALL(*stream_reader, ReadRawData(_, _)) | 380 ON_CALL(*stream_reader, ReadRawData(_, _)) |
379 .WillByDefault(Return(0)); | 381 .WillByDefault(Return(0)); |
380 | 382 |
381 SetUpTestJob(std::move(stream_reader)); | 383 SetUpTestJob(std::move(stream_reader)); |
382 | 384 |
383 SetRange(req_.get(), offset, bytes_available); | 385 SetRange(req_.get(), offset, bytes_available); |
384 req_->Start(); | 386 req_->Start(); |
385 | 387 |
386 loop.Run(); | 388 loop.Run(); |
387 | 389 |
388 EXPECT_EQ(0, network_delegate_.completed_requests()); | 390 EXPECT_EQ(0, network_delegate_.completed_requests()); |
389 req_->Cancel(); | 391 req_->Cancel(); |
390 EXPECT_EQ(1, network_delegate_.completed_requests()); | 392 EXPECT_EQ(1, network_delegate_.completed_requests()); |
391 } | 393 } |
392 | 394 |
393 TEST_F(AndroidStreamReaderURLRequestJobTest, DeleteJobMidWayRead) { | 395 TEST_F(AndroidStreamReaderURLRequestJobTest, DeleteJobMidWayRead) { |
394 const int offset = 20; | 396 const int offset = 20; |
395 const int bytes_available = 128; | 397 const int bytes_available = 128; |
396 base::RunLoop loop; | 398 base::RunLoop loop; |
397 scoped_ptr<StrictMock<MockInputStreamReader> > stream_reader( | 399 std::unique_ptr<StrictMock<MockInputStreamReader>> stream_reader( |
398 new StrictMock<MockInputStreamReader>()); | 400 new StrictMock<MockInputStreamReader>()); |
399 net::CompletionCallback read_completion_callback; | 401 net::CompletionCallback read_completion_callback; |
400 EXPECT_CALL(*stream_reader, Seek(_)) | 402 EXPECT_CALL(*stream_reader, Seek(_)) |
401 .WillOnce(Return(bytes_available)); | 403 .WillOnce(Return(bytes_available)); |
402 EXPECT_CALL(*stream_reader, ReadRawData(_, _)) | 404 EXPECT_CALL(*stream_reader, ReadRawData(_, _)) |
403 .WillOnce(DoAll(InvokeWithoutArgs(&loop, &base::RunLoop::Quit), | 405 .WillOnce(DoAll(InvokeWithoutArgs(&loop, &base::RunLoop::Quit), |
404 Return(bytes_available))); | 406 Return(bytes_available))); |
405 | 407 |
406 SetUpTestJob(std::move(stream_reader)); | 408 SetUpTestJob(std::move(stream_reader)); |
407 | 409 |
408 SetRange(req_.get(), offset, bytes_available); | 410 SetRange(req_.get(), offset, bytes_available); |
409 req_->Start(); | 411 req_->Start(); |
410 | 412 |
411 loop.Run(); | 413 loop.Run(); |
412 | 414 |
413 EXPECT_EQ(0, network_delegate_.completed_requests()); | 415 EXPECT_EQ(0, network_delegate_.completed_requests()); |
414 req_->Cancel(); | 416 req_->Cancel(); |
415 EXPECT_EQ(1, network_delegate_.completed_requests()); | 417 EXPECT_EQ(1, network_delegate_.completed_requests()); |
416 } | 418 } |
417 | 419 |
418 } // namespace android_webview | 420 } // namespace android_webview |
OLD | NEW |