OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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 "webkit/fileapi/webfilewriter_base.h" | 5 #include "webkit/fileapi/webfilewriter_base.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "base/memory/scoped_ptr.h" | 8 #include "base/memory/scoped_ptr.h" |
9 #include "base/message_loop.h" | 9 #include "base/message_loop.h" |
10 #include "base/utf_string_conversions.h" | 10 #include "base/utf_string_conversions.h" |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
44 reset(); | 44 reset(); |
45 } | 45 } |
46 | 46 |
47 void reset() { | 47 void reset() { |
48 received_truncate_ = false; | 48 received_truncate_ = false; |
49 received_truncate_path_ = GURL(); | 49 received_truncate_path_ = GURL(); |
50 received_truncate_offset_ = kNoOffset; | 50 received_truncate_offset_ = kNoOffset; |
51 received_write_ = false; | 51 received_write_ = false; |
52 received_write_path_ = GURL(); | 52 received_write_path_ = GURL(); |
53 received_write_offset_ = kNoOffset; | 53 received_write_offset_ = kNoOffset; |
54 received_write_blob_url_ = GURL(); | 54 received_write_blob_uuid_ = std::string(); |
55 received_cancel_ = false; | 55 received_cancel_ = false; |
56 } | 56 } |
57 | 57 |
58 bool received_truncate_; | 58 bool received_truncate_; |
59 GURL received_truncate_path_; | 59 GURL received_truncate_path_; |
60 int64 received_truncate_offset_; | 60 int64 received_truncate_offset_; |
61 bool received_write_; | 61 bool received_write_; |
62 GURL received_write_path_; | 62 GURL received_write_path_; |
63 GURL received_write_blob_url_; | 63 std::string received_write_blob_uuid_; |
64 int64 received_write_offset_; | 64 int64 received_write_offset_; |
65 bool received_cancel_; | 65 bool received_cancel_; |
66 | 66 |
67 protected: | 67 protected: |
68 virtual void DoTruncate(const GURL& path, int64 offset) OVERRIDE { | 68 virtual void DoTruncate(const GURL& path, int64 offset) OVERRIDE { |
69 received_truncate_ = true; | 69 received_truncate_ = true; |
70 received_truncate_path_ = path; | 70 received_truncate_path_ = path; |
71 received_truncate_offset_ = offset; | 71 received_truncate_offset_ = offset; |
72 | 72 |
73 if (offset == kBasicFileTruncate_Offset) { | 73 if (offset == kBasicFileTruncate_Offset) { |
74 DidSucceed(); | 74 DidSucceed(); |
75 } else if (offset == kErrorFileTruncate_Offset) { | 75 } else if (offset == kErrorFileTruncate_Offset) { |
76 DidFail(base::PLATFORM_FILE_ERROR_NOT_FOUND); | 76 DidFail(base::PLATFORM_FILE_ERROR_NOT_FOUND); |
77 } else if (offset == kCancelFileTruncate_Offset) { | 77 } else if (offset == kCancelFileTruncate_Offset) { |
78 cancel(); | 78 cancel(); |
79 DidSucceed(); // truncate completion | 79 DidSucceed(); // truncate completion |
80 DidSucceed(); // cancel completion | 80 DidSucceed(); // cancel completion |
81 } else if (offset == kCancelFailedTruncate_Offset) { | 81 } else if (offset == kCancelFailedTruncate_Offset) { |
82 cancel(); | 82 cancel(); |
83 DidFail(base::PLATFORM_FILE_ERROR_NOT_FOUND); // truncate completion | 83 DidFail(base::PLATFORM_FILE_ERROR_NOT_FOUND); // truncate completion |
84 DidSucceed(); // cancel completion | 84 DidSucceed(); // cancel completion |
85 } else { | 85 } else { |
86 FAIL(); | 86 FAIL(); |
87 } | 87 } |
88 } | 88 } |
89 | 89 |
90 virtual void DoWrite(const GURL& path, const GURL& blob_url, | 90 virtual void DoWrite(const GURL& path, const std::string& blob_uuid, |
91 int64 offset) OVERRIDE { | 91 int64 offset) OVERRIDE { |
92 received_write_ = true; | 92 received_write_ = true; |
93 received_write_path_ = path; | 93 received_write_path_ = path; |
94 received_write_offset_ = offset; | 94 received_write_offset_ = offset; |
95 received_write_blob_url_ = blob_url; | 95 received_write_blob_uuid_ = blob_uuid; |
96 | 96 |
97 if (offset == kBasicFileWrite_Offset) { | 97 if (offset == kBasicFileWrite_Offset) { |
98 DidWrite(1, true); | 98 DidWrite(1, true); |
99 } else if (offset == kErrorFileWrite_Offset) { | 99 } else if (offset == kErrorFileWrite_Offset) { |
100 DidFail(base::PLATFORM_FILE_ERROR_NOT_FOUND); | 100 DidFail(base::PLATFORM_FILE_ERROR_NOT_FOUND); |
101 } else if (offset == kMultiFileWrite_Offset) { | 101 } else if (offset == kMultiFileWrite_Offset) { |
102 DidWrite(1, false); | 102 DidWrite(1, false); |
103 DidWrite(1, false); | 103 DidWrite(1, false); |
104 DidWrite(1, true); | 104 DidWrite(1, true); |
105 } else if (offset == kCancelFileWriteBeforeCompletion_Offset) { | 105 } else if (offset == kCancelFileWriteBeforeCompletion_Offset) { |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
185 bool received_did_write_complete_; | 185 bool received_did_write_complete_; |
186 bool received_did_truncate_; | 186 bool received_did_truncate_; |
187 bool received_did_fail_; | 187 bool received_did_fail_; |
188 WebKit::WebFileError fail_error_received_; | 188 WebKit::WebFileError fail_error_received_; |
189 | 189 |
190 DISALLOW_COPY_AND_ASSIGN(FileWriterTest); | 190 DISALLOW_COPY_AND_ASSIGN(FileWriterTest); |
191 }; | 191 }; |
192 | 192 |
193 TEST_F(FileWriterTest, BasicFileWrite) { | 193 TEST_F(FileWriterTest, BasicFileWrite) { |
194 // Call the webkit facing api. | 194 // Call the webkit facing api. |
195 const GURL kBlobUrl("blob://bloburl/"); | 195 const std::string kBlobUUID("abc-123"); |
196 writer()->write(kBasicFileWrite_Offset, kBlobUrl); | 196 writer()->write(kBasicFileWrite_Offset, |
| 197 WebKit::WebString::fromUTF8(kBlobUUID.data())); |
197 | 198 |
198 // Check that the derived class gets called correctly. | 199 // Check that the derived class gets called correctly. |
199 EXPECT_TRUE(testable_writer_->received_write_); | 200 EXPECT_TRUE(testable_writer_->received_write_); |
200 EXPECT_EQ(testable_writer_->received_write_path_, | 201 EXPECT_EQ(testable_writer_->received_write_path_, |
201 mock_path_as_gurl()); | 202 mock_path_as_gurl()); |
202 EXPECT_EQ(kBasicFileWrite_Offset, | 203 EXPECT_EQ(kBasicFileWrite_Offset, |
203 testable_writer_->received_write_offset_); | 204 testable_writer_->received_write_offset_); |
204 EXPECT_EQ(kBlobUrl, testable_writer_->received_write_blob_url_); | 205 EXPECT_EQ(kBlobUUID, testable_writer_->received_write_blob_uuid_); |
205 EXPECT_FALSE(testable_writer_->received_truncate_); | 206 EXPECT_FALSE(testable_writer_->received_truncate_); |
206 EXPECT_FALSE(testable_writer_->received_cancel_); | 207 EXPECT_FALSE(testable_writer_->received_cancel_); |
207 | 208 |
208 // Check that the client gets called correctly. | 209 // Check that the client gets called correctly. |
209 EXPECT_EQ(1, received_did_write_count_); | 210 EXPECT_EQ(1, received_did_write_count_); |
210 EXPECT_TRUE(received_did_write_complete_); | 211 EXPECT_TRUE(received_did_write_complete_); |
211 EXPECT_EQ(1, received_did_write_bytes_total_); | 212 EXPECT_EQ(1, received_did_write_bytes_total_); |
212 EXPECT_FALSE(received_did_truncate_); | 213 EXPECT_FALSE(received_did_truncate_); |
213 EXPECT_FALSE(received_did_fail_); | 214 EXPECT_FALSE(received_did_fail_); |
214 } | 215 } |
(...skipping 12 matching lines...) Expand all Loading... |
227 EXPECT_FALSE(testable_writer_->received_cancel_); | 228 EXPECT_FALSE(testable_writer_->received_cancel_); |
228 | 229 |
229 // Check that the client gets called correctly. | 230 // Check that the client gets called correctly. |
230 EXPECT_TRUE(received_did_truncate_); | 231 EXPECT_TRUE(received_did_truncate_); |
231 EXPECT_EQ(0, received_did_write_count_); | 232 EXPECT_EQ(0, received_did_write_count_); |
232 EXPECT_FALSE(received_did_fail_); | 233 EXPECT_FALSE(received_did_fail_); |
233 } | 234 } |
234 | 235 |
235 TEST_F(FileWriterTest, ErrorFileWrite) { | 236 TEST_F(FileWriterTest, ErrorFileWrite) { |
236 // Call the webkit facing api. | 237 // Call the webkit facing api. |
237 const GURL kBlobUrl("blob://bloburl/"); | 238 const std::string kBlobUUID("abc-123"); |
238 writer()->write(kErrorFileWrite_Offset, kBlobUrl); | 239 writer()->write(kErrorFileWrite_Offset, |
| 240 WebKit::WebString::fromUTF8(kBlobUUID.data())); |
239 | 241 |
240 // Check that the derived class gets called correctly. | 242 // Check that the derived class gets called correctly. |
241 EXPECT_TRUE(testable_writer_->received_write_); | 243 EXPECT_TRUE(testable_writer_->received_write_); |
242 EXPECT_EQ(testable_writer_->received_write_path_, | 244 EXPECT_EQ(testable_writer_->received_write_path_, |
243 mock_path_as_gurl()); | 245 mock_path_as_gurl()); |
244 EXPECT_EQ(kErrorFileWrite_Offset, | 246 EXPECT_EQ(kErrorFileWrite_Offset, |
245 testable_writer_->received_write_offset_); | 247 testable_writer_->received_write_offset_); |
246 EXPECT_EQ(kBlobUrl, testable_writer_->received_write_blob_url_); | 248 EXPECT_EQ(kBlobUUID, testable_writer_->received_write_blob_uuid_); |
247 EXPECT_FALSE(testable_writer_->received_truncate_); | 249 EXPECT_FALSE(testable_writer_->received_truncate_); |
248 EXPECT_FALSE(testable_writer_->received_cancel_); | 250 EXPECT_FALSE(testable_writer_->received_cancel_); |
249 | 251 |
250 // Check that the client gets called correctly. | 252 // Check that the client gets called correctly. |
251 EXPECT_TRUE(received_did_fail_); | 253 EXPECT_TRUE(received_did_fail_); |
252 EXPECT_EQ(WebKit::WebFileErrorNotFound, fail_error_received_); | 254 EXPECT_EQ(WebKit::WebFileErrorNotFound, fail_error_received_); |
253 EXPECT_EQ(0, received_did_write_count_); | 255 EXPECT_EQ(0, received_did_write_count_); |
254 EXPECT_FALSE(received_did_truncate_); | 256 EXPECT_FALSE(received_did_truncate_); |
255 } | 257 } |
256 | 258 |
(...skipping 12 matching lines...) Expand all Loading... |
269 | 271 |
270 // Check that the client gets called correctly. | 272 // Check that the client gets called correctly. |
271 EXPECT_TRUE(received_did_fail_); | 273 EXPECT_TRUE(received_did_fail_); |
272 EXPECT_EQ(WebKit::WebFileErrorNotFound, fail_error_received_); | 274 EXPECT_EQ(WebKit::WebFileErrorNotFound, fail_error_received_); |
273 EXPECT_FALSE(received_did_truncate_); | 275 EXPECT_FALSE(received_did_truncate_); |
274 EXPECT_EQ(0, received_did_write_count_); | 276 EXPECT_EQ(0, received_did_write_count_); |
275 } | 277 } |
276 | 278 |
277 TEST_F(FileWriterTest, MultiFileWrite) { | 279 TEST_F(FileWriterTest, MultiFileWrite) { |
278 // Call the webkit facing api. | 280 // Call the webkit facing api. |
279 const GURL kBlobUrl("blob://bloburl/"); | 281 const std::string kBlobUUID("abc-123"); |
280 writer()->write(kMultiFileWrite_Offset, kBlobUrl); | 282 writer()->write(kMultiFileWrite_Offset, |
| 283 WebKit::WebString::fromUTF8(kBlobUUID.data())); |
281 | 284 |
282 // Check that the derived class gets called correctly. | 285 // Check that the derived class gets called correctly. |
283 EXPECT_TRUE(testable_writer_->received_write_); | 286 EXPECT_TRUE(testable_writer_->received_write_); |
284 EXPECT_EQ(testable_writer_->received_write_path_, | 287 EXPECT_EQ(testable_writer_->received_write_path_, |
285 mock_path_as_gurl()); | 288 mock_path_as_gurl()); |
286 EXPECT_EQ(kMultiFileWrite_Offset, | 289 EXPECT_EQ(kMultiFileWrite_Offset, |
287 testable_writer_->received_write_offset_); | 290 testable_writer_->received_write_offset_); |
288 EXPECT_EQ(kBlobUrl, testable_writer_->received_write_blob_url_); | 291 EXPECT_EQ(kBlobUUID, testable_writer_->received_write_blob_uuid_); |
289 EXPECT_FALSE(testable_writer_->received_truncate_); | 292 EXPECT_FALSE(testable_writer_->received_truncate_); |
290 EXPECT_FALSE(testable_writer_->received_cancel_); | 293 EXPECT_FALSE(testable_writer_->received_cancel_); |
291 | 294 |
292 // Check that the client gets called correctly. | 295 // Check that the client gets called correctly. |
293 EXPECT_EQ(3, received_did_write_count_); | 296 EXPECT_EQ(3, received_did_write_count_); |
294 EXPECT_TRUE(received_did_write_complete_); | 297 EXPECT_TRUE(received_did_write_complete_); |
295 EXPECT_EQ(3, received_did_write_bytes_total_); | 298 EXPECT_EQ(3, received_did_write_bytes_total_); |
296 EXPECT_FALSE(received_did_truncate_); | 299 EXPECT_FALSE(received_did_truncate_); |
297 EXPECT_FALSE(received_did_fail_); | 300 EXPECT_FALSE(received_did_fail_); |
298 } | 301 } |
299 | 302 |
300 TEST_F(FileWriterTest, CancelFileWriteBeforeCompletion) { | 303 TEST_F(FileWriterTest, CancelFileWriteBeforeCompletion) { |
301 // Call the webkit facing api. | 304 // Call the webkit facing api. |
302 const GURL kBlobUrl("blob://bloburl/"); | 305 const std::string kBlobUUID("abc-123"); |
303 writer()->write(kCancelFileWriteBeforeCompletion_Offset, kBlobUrl); | 306 writer()->write(kCancelFileWriteBeforeCompletion_Offset, |
| 307 WebKit::WebString::fromUTF8(kBlobUUID.data())); |
304 | 308 |
305 // Check that the derived class gets called correctly. | 309 // Check that the derived class gets called correctly. |
306 EXPECT_TRUE(testable_writer_->received_write_); | 310 EXPECT_TRUE(testable_writer_->received_write_); |
307 EXPECT_EQ(testable_writer_->received_write_path_, | 311 EXPECT_EQ(testable_writer_->received_write_path_, |
308 mock_path_as_gurl()); | 312 mock_path_as_gurl()); |
309 EXPECT_EQ(kCancelFileWriteBeforeCompletion_Offset, | 313 EXPECT_EQ(kCancelFileWriteBeforeCompletion_Offset, |
310 testable_writer_->received_write_offset_); | 314 testable_writer_->received_write_offset_); |
311 EXPECT_EQ(kBlobUrl, testable_writer_->received_write_blob_url_); | 315 EXPECT_EQ(kBlobUUID, testable_writer_->received_write_blob_uuid_); |
312 EXPECT_TRUE(testable_writer_->received_cancel_); | 316 EXPECT_TRUE(testable_writer_->received_cancel_); |
313 EXPECT_FALSE(testable_writer_->received_truncate_); | 317 EXPECT_FALSE(testable_writer_->received_truncate_); |
314 | 318 |
315 // Check that the client gets called correctly. | 319 // Check that the client gets called correctly. |
316 EXPECT_TRUE(received_did_fail_); | 320 EXPECT_TRUE(received_did_fail_); |
317 EXPECT_EQ(WebKit::WebFileErrorAbort, fail_error_received_); | 321 EXPECT_EQ(WebKit::WebFileErrorAbort, fail_error_received_); |
318 EXPECT_EQ(1, received_did_write_count_); | 322 EXPECT_EQ(1, received_did_write_count_); |
319 EXPECT_FALSE(received_did_write_complete_); | 323 EXPECT_FALSE(received_did_write_complete_); |
320 EXPECT_EQ(1, received_did_write_bytes_total_); | 324 EXPECT_EQ(1, received_did_write_bytes_total_); |
321 EXPECT_FALSE(received_did_truncate_); | 325 EXPECT_FALSE(received_did_truncate_); |
322 } | 326 } |
323 | 327 |
324 TEST_F(FileWriterTest, CancelFileWriteAfterCompletion) { | 328 TEST_F(FileWriterTest, CancelFileWriteAfterCompletion) { |
325 // Call the webkit facing api. | 329 // Call the webkit facing api. |
326 const GURL kBlobUrl("blob://bloburl/"); | 330 const std::string kBlobUUID("abc-123"); |
327 writer()->write(kCancelFileWriteAfterCompletion_Offset, kBlobUrl); | 331 writer()->write(kCancelFileWriteAfterCompletion_Offset, |
| 332 WebKit::WebString::fromUTF8(kBlobUUID.data())); |
328 | 333 |
329 // Check that the derived class gets called correctly. | 334 // Check that the derived class gets called correctly. |
330 EXPECT_TRUE(testable_writer_->received_write_); | 335 EXPECT_TRUE(testable_writer_->received_write_); |
331 EXPECT_EQ(testable_writer_->received_write_path_, | 336 EXPECT_EQ(testable_writer_->received_write_path_, |
332 mock_path_as_gurl()); | 337 mock_path_as_gurl()); |
333 EXPECT_EQ(kCancelFileWriteAfterCompletion_Offset, | 338 EXPECT_EQ(kCancelFileWriteAfterCompletion_Offset, |
334 testable_writer_->received_write_offset_); | 339 testable_writer_->received_write_offset_); |
335 EXPECT_EQ(kBlobUrl, testable_writer_->received_write_blob_url_); | 340 EXPECT_EQ(kBlobUUID, testable_writer_->received_write_blob_uuid_); |
336 EXPECT_TRUE(testable_writer_->received_cancel_); | 341 EXPECT_TRUE(testable_writer_->received_cancel_); |
337 EXPECT_FALSE(testable_writer_->received_truncate_); | 342 EXPECT_FALSE(testable_writer_->received_truncate_); |
338 | 343 |
339 // Check that the client gets called correctly. | 344 // Check that the client gets called correctly. |
340 EXPECT_TRUE(received_did_fail_); | 345 EXPECT_TRUE(received_did_fail_); |
341 EXPECT_EQ(WebKit::WebFileErrorAbort, fail_error_received_); | 346 EXPECT_EQ(WebKit::WebFileErrorAbort, fail_error_received_); |
342 EXPECT_EQ(1, received_did_write_count_); | 347 EXPECT_EQ(1, received_did_write_count_); |
343 EXPECT_FALSE(received_did_write_complete_); | 348 EXPECT_FALSE(received_did_write_complete_); |
344 EXPECT_EQ(1, received_did_write_bytes_total_); | 349 EXPECT_EQ(1, received_did_write_bytes_total_); |
345 EXPECT_FALSE(received_did_truncate_); | 350 EXPECT_FALSE(received_did_truncate_); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
379 EXPECT_FALSE(testable_writer_->received_write_); | 384 EXPECT_FALSE(testable_writer_->received_write_); |
380 | 385 |
381 // Check that the client gets called correctly. | 386 // Check that the client gets called correctly. |
382 EXPECT_TRUE(received_did_fail_); | 387 EXPECT_TRUE(received_did_fail_); |
383 EXPECT_EQ(WebKit::WebFileErrorAbort, fail_error_received_); | 388 EXPECT_EQ(WebKit::WebFileErrorAbort, fail_error_received_); |
384 EXPECT_FALSE(received_did_truncate_); | 389 EXPECT_FALSE(received_did_truncate_); |
385 EXPECT_EQ(0, received_did_write_count_); | 390 EXPECT_EQ(0, received_did_write_count_); |
386 } | 391 } |
387 | 392 |
388 TEST_F(FileWriterTest, DeleteInCompletionCallbacks) { | 393 TEST_F(FileWriterTest, DeleteInCompletionCallbacks) { |
| 394 const std::string kBlobUUID("abc-123"); |
389 delete_in_client_callback_ = true; | 395 delete_in_client_callback_ = true; |
390 writer()->write(kBasicFileWrite_Offset, GURL("blob://bloburl/")); | 396 writer()->write(kBasicFileWrite_Offset, |
| 397 WebKit::WebString::fromUTF8(kBlobUUID.data())); |
391 EXPECT_FALSE(testable_writer_.get()); | 398 EXPECT_FALSE(testable_writer_.get()); |
392 | 399 |
393 reset(); | 400 reset(); |
394 delete_in_client_callback_ = true; | 401 delete_in_client_callback_ = true; |
395 writer()->truncate(kBasicFileTruncate_Offset); | 402 writer()->truncate(kBasicFileTruncate_Offset); |
396 EXPECT_FALSE(testable_writer_.get()); | 403 EXPECT_FALSE(testable_writer_.get()); |
397 | 404 |
398 reset(); | 405 reset(); |
399 delete_in_client_callback_ = true; | 406 delete_in_client_callback_ = true; |
400 writer()->write(kErrorFileWrite_Offset, GURL("blob://bloburl/")); | 407 writer()->write(kErrorFileWrite_Offset, |
| 408 WebKit::WebString::fromUTF8(kBlobUUID.data())); |
401 EXPECT_FALSE(testable_writer_.get()); | 409 EXPECT_FALSE(testable_writer_.get()); |
402 | 410 |
403 reset(); | 411 reset(); |
404 delete_in_client_callback_ = true; | 412 delete_in_client_callback_ = true; |
405 writer()->truncate(kErrorFileTruncate_Offset); | 413 writer()->truncate(kErrorFileTruncate_Offset); |
406 EXPECT_FALSE(testable_writer_.get()); | 414 EXPECT_FALSE(testable_writer_.get()); |
407 | 415 |
408 // Not crashing counts as passing. | 416 // Not crashing counts as passing. |
409 } | 417 } |
410 | 418 |
411 } // namespace fileapi | 419 } // namespace fileapi |
OLD | NEW |