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 "chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_st
ream_reader.h" |
| 6 |
5 #include <stdint.h> | 7 #include <stdint.h> |
6 | 8 |
| 9 #include <memory> |
7 #include <string> | 10 #include <string> |
8 #include <vector> | 11 #include <vector> |
9 | 12 |
10 #include "base/macros.h" | 13 #include "base/macros.h" |
11 #include "base/memory/ref_counted.h" | 14 #include "base/memory/ref_counted.h" |
12 #include "base/memory/scoped_ptr.h" | |
13 #include "base/run_loop.h" | 15 #include "base/run_loop.h" |
14 #include "base/thread_task_runner_handle.h" | 16 #include "base/thread_task_runner_handle.h" |
15 #include "chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_st
ream_reader.h" | |
16 #include "chrome/browser/chromeos/fileapi/file_system_backend.h" | 17 #include "chrome/browser/chromeos/fileapi/file_system_backend.h" |
17 #include "content/public/test/test_browser_thread_bundle.h" | 18 #include "content/public/test/test_browser_thread_bundle.h" |
18 #include "net/base/io_buffer.h" | 19 #include "net/base/io_buffer.h" |
19 #include "net/base/net_errors.h" | 20 #include "net/base/net_errors.h" |
20 #include "testing/gtest/include/gtest/gtest.h" | 21 #include "testing/gtest/include/gtest/gtest.h" |
21 | 22 |
22 namespace chromeos { | 23 namespace chromeos { |
23 namespace file_system_provider { | 24 namespace file_system_provider { |
24 namespace { | 25 namespace { |
25 | 26 |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
85 protected: | 86 protected: |
86 FileSystemProviderBufferingFileStreamReaderTest() {} | 87 FileSystemProviderBufferingFileStreamReaderTest() {} |
87 ~FileSystemProviderBufferingFileStreamReaderTest() override {} | 88 ~FileSystemProviderBufferingFileStreamReaderTest() override {} |
88 | 89 |
89 content::TestBrowserThreadBundle thread_bundle_; | 90 content::TestBrowserThreadBundle thread_bundle_; |
90 }; | 91 }; |
91 | 92 |
92 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) { | 93 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) { |
93 std::vector<int> inner_read_log; | 94 std::vector<int> inner_read_log; |
94 BufferingFileStreamReader reader( | 95 BufferingFileStreamReader reader( |
95 scoped_ptr<storage::FileStreamReader>( | 96 std::unique_ptr<storage::FileStreamReader>( |
96 new FakeFileStreamReader(&inner_read_log, net::OK)), | 97 new FakeFileStreamReader(&inner_read_log, net::OK)), |
97 kPreloadingBufferLength, | 98 kPreloadingBufferLength, kFileSize); |
98 kFileSize); | |
99 | 99 |
100 // For the first read, the internal file stream reader is fired, as there is | 100 // For the first read, the internal file stream reader is fired, as there is |
101 // no data in the preloading buffer. | 101 // no data in the preloading buffer. |
102 { | 102 { |
103 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize)); | 103 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize)); |
104 std::vector<int> read_log; | 104 std::vector<int> read_log; |
105 const int result = reader.Read( | 105 const int result = reader.Read( |
106 buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log)); | 106 buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log)); |
107 base::RunLoop().RunUntilIdle(); | 107 base::RunLoop().RunUntilIdle(); |
108 | 108 |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
159 ASSERT_EQ(1u, inner_read_log.size()); | 159 ASSERT_EQ(1u, inner_read_log.size()); |
160 EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]); | 160 EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]); |
161 ASSERT_EQ(1u, read_log.size()); | 161 ASSERT_EQ(1u, read_log.size()); |
162 EXPECT_EQ(kChunkSize, read_log[0]); | 162 EXPECT_EQ(kChunkSize, read_log[0]); |
163 } | 163 } |
164 } | 164 } |
165 | 165 |
166 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) { | 166 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) { |
167 std::vector<int> inner_read_log; | 167 std::vector<int> inner_read_log; |
168 BufferingFileStreamReader reader( | 168 BufferingFileStreamReader reader( |
169 scoped_ptr<storage::FileStreamReader>( | 169 std::unique_ptr<storage::FileStreamReader>( |
170 new FakeFileStreamReader(&inner_read_log, net::OK)), | 170 new FakeFileStreamReader(&inner_read_log, net::OK)), |
171 kPreloadingBufferLength, | 171 kPreloadingBufferLength, kFileSize); |
172 kFileSize); | |
173 | 172 |
174 // First read couple of bytes, so the internal buffer is filled out. | 173 // First read couple of bytes, so the internal buffer is filled out. |
175 { | 174 { |
176 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize)); | 175 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize)); |
177 std::vector<int> read_log; | 176 std::vector<int> read_log; |
178 const int result = reader.Read( | 177 const int result = reader.Read( |
179 buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log)); | 178 buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log)); |
180 base::RunLoop().RunUntilIdle(); | 179 base::RunLoop().RunUntilIdle(); |
181 | 180 |
182 EXPECT_EQ(net::ERR_IO_PENDING, result); | 181 EXPECT_EQ(net::ERR_IO_PENDING, result); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
220 EXPECT_EQ(read_bytes, inner_read_log[0]); | 219 EXPECT_EQ(read_bytes, inner_read_log[0]); |
221 ASSERT_EQ(1u, read_log.size()); | 220 ASSERT_EQ(1u, read_log.size()); |
222 EXPECT_EQ(read_bytes, read_log[0]); | 221 EXPECT_EQ(read_bytes, read_log[0]); |
223 } | 222 } |
224 } | 223 } |
225 | 224 |
226 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, | 225 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, |
227 Read_MoreThanBufferSize) { | 226 Read_MoreThanBufferSize) { |
228 std::vector<int> inner_read_log; | 227 std::vector<int> inner_read_log; |
229 BufferingFileStreamReader reader( | 228 BufferingFileStreamReader reader( |
230 scoped_ptr<storage::FileStreamReader>( | 229 std::unique_ptr<storage::FileStreamReader>( |
231 new FakeFileStreamReader(&inner_read_log, net::OK)), | 230 new FakeFileStreamReader(&inner_read_log, net::OK)), |
232 kPreloadingBufferLength, | 231 kPreloadingBufferLength, kFileSize); |
233 kFileSize); | |
234 // First read couple of bytes, so the internal buffer is filled out. | 232 // First read couple of bytes, so the internal buffer is filled out. |
235 { | 233 { |
236 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize)); | 234 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize)); |
237 std::vector<int> read_log; | 235 std::vector<int> read_log; |
238 const int result = reader.Read( | 236 const int result = reader.Read( |
239 buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log)); | 237 buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log)); |
240 base::RunLoop().RunUntilIdle(); | 238 base::RunLoop().RunUntilIdle(); |
241 | 239 |
242 EXPECT_EQ(net::ERR_IO_PENDING, result); | 240 EXPECT_EQ(net::ERR_IO_PENDING, result); |
243 ASSERT_EQ(1u, inner_read_log.size()); | 241 ASSERT_EQ(1u, inner_read_log.size()); |
(...skipping 19 matching lines...) Expand all Loading... |
263 EXPECT_EQ(0u, read_log.size()); | 261 EXPECT_EQ(0u, read_log.size()); |
264 } | 262 } |
265 } | 263 } |
266 | 264 |
267 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, | 265 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, |
268 Read_LessThanBufferSize) { | 266 Read_LessThanBufferSize) { |
269 std::vector<int> inner_read_log; | 267 std::vector<int> inner_read_log; |
270 const int total_bytes_to_read = 3; | 268 const int total_bytes_to_read = 3; |
271 ASSERT_LT(total_bytes_to_read, kPreloadingBufferLength); | 269 ASSERT_LT(total_bytes_to_read, kPreloadingBufferLength); |
272 BufferingFileStreamReader reader( | 270 BufferingFileStreamReader reader( |
273 scoped_ptr<storage::FileStreamReader>( | 271 std::unique_ptr<storage::FileStreamReader>( |
274 new FakeFileStreamReader(&inner_read_log, net::OK)), | 272 new FakeFileStreamReader(&inner_read_log, net::OK)), |
275 kPreloadingBufferLength, | 273 kPreloadingBufferLength, total_bytes_to_read); |
276 total_bytes_to_read); | |
277 | 274 |
278 // For the first read, the internal file stream reader is fired, as there is | 275 // For the first read, the internal file stream reader is fired, as there is |
279 // no data in the preloading buffer. | 276 // no data in the preloading buffer. |
280 const int read_bytes = 2; | 277 const int read_bytes = 2; |
281 ASSERT_LT(read_bytes, kPreloadingBufferLength); | 278 ASSERT_LT(read_bytes, kPreloadingBufferLength); |
282 ASSERT_LE(read_bytes, total_bytes_to_read); | 279 ASSERT_LE(read_bytes, total_bytes_to_read); |
283 | 280 |
284 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes)); | 281 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes)); |
285 std::vector<int> read_log; | 282 std::vector<int> read_log; |
286 const int result = reader.Read( | 283 const int result = reader.Read( |
287 buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log)); | 284 buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log)); |
288 base::RunLoop().RunUntilIdle(); | 285 base::RunLoop().RunUntilIdle(); |
289 | 286 |
290 EXPECT_EQ(net::ERR_IO_PENDING, result); | 287 EXPECT_EQ(net::ERR_IO_PENDING, result); |
291 ASSERT_EQ(1u, inner_read_log.size()); | 288 ASSERT_EQ(1u, inner_read_log.size()); |
292 EXPECT_EQ(total_bytes_to_read, inner_read_log[0]); | 289 EXPECT_EQ(total_bytes_to_read, inner_read_log[0]); |
293 ASSERT_EQ(1u, read_log.size()); | 290 ASSERT_EQ(1u, read_log.size()); |
294 EXPECT_EQ(read_bytes, read_log[0]); | 291 EXPECT_EQ(read_bytes, read_log[0]); |
295 } | 292 } |
296 | 293 |
297 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, | 294 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, |
298 Read_LessThanBufferSize_WithoutSpecifiedLength) { | 295 Read_LessThanBufferSize_WithoutSpecifiedLength) { |
299 std::vector<int> inner_read_log; | 296 std::vector<int> inner_read_log; |
300 BufferingFileStreamReader reader( | 297 BufferingFileStreamReader reader( |
301 scoped_ptr<storage::FileStreamReader>( | 298 std::unique_ptr<storage::FileStreamReader>( |
302 new FakeFileStreamReader(&inner_read_log, net::OK)), | 299 new FakeFileStreamReader(&inner_read_log, net::OK)), |
303 kPreloadingBufferLength, | 300 kPreloadingBufferLength, storage::kMaximumLength); |
304 storage::kMaximumLength); | |
305 | 301 |
306 // For the first read, the internal file stream reader is fired, as there is | 302 // For the first read, the internal file stream reader is fired, as there is |
307 // no data in the preloading buffer. | 303 // no data in the preloading buffer. |
308 const int read_bytes = 2; | 304 const int read_bytes = 2; |
309 ASSERT_LT(read_bytes, kPreloadingBufferLength); | 305 ASSERT_LT(read_bytes, kPreloadingBufferLength); |
310 | 306 |
311 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes)); | 307 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes)); |
312 std::vector<int> read_log; | 308 std::vector<int> read_log; |
313 const int result = reader.Read( | 309 const int result = reader.Read( |
314 buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log)); | 310 buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log)); |
315 base::RunLoop().RunUntilIdle(); | 311 base::RunLoop().RunUntilIdle(); |
316 | 312 |
317 EXPECT_EQ(net::ERR_IO_PENDING, result); | 313 EXPECT_EQ(net::ERR_IO_PENDING, result); |
318 ASSERT_EQ(1u, inner_read_log.size()); | 314 ASSERT_EQ(1u, inner_read_log.size()); |
319 EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]); | 315 EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]); |
320 ASSERT_EQ(1u, read_log.size()); | 316 ASSERT_EQ(1u, read_log.size()); |
321 EXPECT_EQ(read_bytes, read_log[0]); | 317 EXPECT_EQ(read_bytes, read_log[0]); |
322 } | 318 } |
323 | 319 |
324 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_WithError) { | 320 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_WithError) { |
325 std::vector<int> inner_read_log; | 321 std::vector<int> inner_read_log; |
326 BufferingFileStreamReader reader( | 322 BufferingFileStreamReader reader( |
327 scoped_ptr<storage::FileStreamReader>( | 323 std::unique_ptr<storage::FileStreamReader>( |
328 new FakeFileStreamReader(&inner_read_log, net::ERR_ACCESS_DENIED)), | 324 new FakeFileStreamReader(&inner_read_log, net::ERR_ACCESS_DENIED)), |
329 kPreloadingBufferLength, | 325 kPreloadingBufferLength, kFileSize); |
330 kFileSize); | |
331 | 326 |
332 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize)); | 327 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize)); |
333 std::vector<int> read_log; | 328 std::vector<int> read_log; |
334 const int result = reader.Read( | 329 const int result = reader.Read( |
335 buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log)); | 330 buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log)); |
336 base::RunLoop().RunUntilIdle(); | 331 base::RunLoop().RunUntilIdle(); |
337 | 332 |
338 EXPECT_EQ(net::ERR_IO_PENDING, result); | 333 EXPECT_EQ(net::ERR_IO_PENDING, result); |
339 ASSERT_EQ(1u, inner_read_log.size()); | 334 ASSERT_EQ(1u, inner_read_log.size()); |
340 EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]); | 335 EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]); |
341 ASSERT_EQ(1u, read_log.size()); | 336 ASSERT_EQ(1u, read_log.size()); |
342 EXPECT_EQ(net::ERR_ACCESS_DENIED, read_log[0]); | 337 EXPECT_EQ(net::ERR_ACCESS_DENIED, read_log[0]); |
343 } | 338 } |
344 | 339 |
345 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, GetLength) { | 340 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, GetLength) { |
346 BufferingFileStreamReader reader(scoped_ptr<storage::FileStreamReader>( | 341 BufferingFileStreamReader reader(std::unique_ptr<storage::FileStreamReader>( |
347 new FakeFileStreamReader(NULL, net::OK)), | 342 new FakeFileStreamReader(NULL, net::OK)), |
348 kPreloadingBufferLength, | 343 kPreloadingBufferLength, kFileSize); |
349 kFileSize); | |
350 | 344 |
351 std::vector<int64_t> get_length_log; | 345 std::vector<int64_t> get_length_log; |
352 const int64_t result = | 346 const int64_t result = |
353 reader.GetLength(base::Bind(&LogValue<int64_t>, &get_length_log)); | 347 reader.GetLength(base::Bind(&LogValue<int64_t>, &get_length_log)); |
354 base::RunLoop().RunUntilIdle(); | 348 base::RunLoop().RunUntilIdle(); |
355 | 349 |
356 EXPECT_EQ(net::ERR_IO_PENDING, result); | 350 EXPECT_EQ(net::ERR_IO_PENDING, result); |
357 ASSERT_EQ(1u, get_length_log.size()); | 351 ASSERT_EQ(1u, get_length_log.size()); |
358 EXPECT_EQ(kFileSize, get_length_log[0]); | 352 EXPECT_EQ(kFileSize, get_length_log[0]); |
359 } | 353 } |
360 | 354 |
361 } // namespace file_system_provider | 355 } // namespace file_system_provider |
362 } // namespace chromeos | 356 } // namespace chromeos |
OLD | NEW |