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/provided_file_system.h" | 5 #include "chrome/browser/chromeos/file_system_provider/provided_file_system.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/files/file.h" | 10 #include "base/files/file.h" |
(...skipping 14 matching lines...) Expand all Loading... |
25 #include "chrome/common/extensions/api/file_system_provider_internal.h" | 25 #include "chrome/common/extensions/api/file_system_provider_internal.h" |
26 #include "chrome/test/base/testing_profile.h" | 26 #include "chrome/test/base/testing_profile.h" |
27 #include "content/public/test/test_browser_thread_bundle.h" | 27 #include "content/public/test/test_browser_thread_bundle.h" |
28 #include "extensions/browser/event_router.h" | 28 #include "extensions/browser/event_router.h" |
29 #include "testing/gtest/include/gtest/gtest.h" | 29 #include "testing/gtest/include/gtest/gtest.h" |
30 | 30 |
31 namespace chromeos { | 31 namespace chromeos { |
32 namespace file_system_provider { | 32 namespace file_system_provider { |
33 namespace { | 33 namespace { |
34 | 34 |
| 35 const char kOrigin[] = |
| 36 "chrome-extension://abcabcabcabcabcabcabcabcabcabcabcabca/"; |
| 37 const char kAnotherOrigin[] = |
| 38 "chrome-extension://efgefgefgefgefgefgefgefgefgefgefgefge/"; |
35 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj"; | 39 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj"; |
36 const char kFileSystemId[] = "camera-pictures"; | 40 const char kFileSystemId[] = "camera-pictures"; |
37 const char kDisplayName[] = "Camera Pictures"; | 41 const char kDisplayName[] = "Camera Pictures"; |
38 const base::FilePath::CharType kDirectoryPath[] = "/hello/world"; | 42 const base::FilePath::CharType kDirectoryPath[] = "/hello/world"; |
39 | 43 |
40 // Fake implementation of the event router, mocking out a real extension. | 44 // Fake implementation of the event router, mocking out a real extension. |
41 // Handles requests and replies with fake answers back to the file system via | 45 // Handles requests and replies with fake answers back to the file system via |
42 // the request manager. | 46 // the request manager. |
43 class FakeEventRouter : public extensions::EventRouter { | 47 class FakeEventRouter : public extensions::EventRouter { |
44 public: | 48 public: |
(...skipping 233 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
278 TEST_F(FileSystemProviderProvidedFileSystemTest, ObserveDirectory_NotFound) { | 282 TEST_F(FileSystemProviderProvidedFileSystemTest, ObserveDirectory_NotFound) { |
279 Log log; | 283 Log log; |
280 Observer observer; | 284 Observer observer; |
281 | 285 |
282 provided_file_system_->AddObserver(&observer); | 286 provided_file_system_->AddObserver(&observer); |
283 | 287 |
284 // First, set the extension response to an error. | 288 // First, set the extension response to an error. |
285 event_router_->set_reply_result(base::File::FILE_ERROR_NOT_FOUND); | 289 event_router_->set_reply_result(base::File::FILE_ERROR_NOT_FOUND); |
286 | 290 |
287 provided_file_system_->ObserveDirectory( | 291 provided_file_system_->ObserveDirectory( |
| 292 GURL(kOrigin), |
288 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 293 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
289 false /* recursive */, | 294 false /* recursive */, |
| 295 false /* persistent */, |
290 base::Bind(&LogStatus, base::Unretained(&log))); | 296 base::Bind(&LogStatus, base::Unretained(&log))); |
291 base::RunLoop().RunUntilIdle(); | 297 base::RunLoop().RunUntilIdle(); |
292 | 298 |
293 // The directory should not become observed because of an error. | 299 // The directory should not become observed because of an error. |
294 ASSERT_EQ(1u, log.size()); | 300 ASSERT_EQ(1u, log.size()); |
295 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, log[0]); | 301 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, log[0]); |
296 | 302 |
297 ObservedEntries* const observed_entries = | 303 ObservedEntries* const observed_entries = |
298 provided_file_system_->GetObservedEntries(); | 304 provided_file_system_->GetObservedEntries(); |
299 EXPECT_EQ(0u, observed_entries->size()); | 305 EXPECT_EQ(0u, observed_entries->size()); |
300 | 306 |
301 // The observer should not be called. | 307 // The observer should not be called. |
302 EXPECT_EQ(0, observer.list_changed_counter()); | 308 EXPECT_EQ(0, observer.list_changed_counter()); |
303 EXPECT_EQ(0, observer.tag_updated_counter()); | 309 EXPECT_EQ(0, observer.tag_updated_counter()); |
304 | 310 |
305 provided_file_system_->RemoveObserver(&observer); | 311 provided_file_system_->RemoveObserver(&observer); |
306 } | 312 } |
307 | 313 |
308 TEST_F(FileSystemProviderProvidedFileSystemTest, ObserveDirectory) { | 314 TEST_F(FileSystemProviderProvidedFileSystemTest, ObserveDirectory) { |
309 Log log; | 315 Log log; |
310 Observer observer; | 316 Observer observer; |
311 | 317 |
312 provided_file_system_->AddObserver(&observer); | 318 provided_file_system_->AddObserver(&observer); |
313 | 319 |
314 provided_file_system_->ObserveDirectory( | 320 provided_file_system_->ObserveDirectory( |
| 321 GURL(kOrigin), |
315 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 322 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
316 false /* recursive */, | 323 false /* recursive */, |
| 324 true /* persistent */, |
317 base::Bind(&LogStatus, base::Unretained(&log))); | 325 base::Bind(&LogStatus, base::Unretained(&log))); |
318 base::RunLoop().RunUntilIdle(); | 326 base::RunLoop().RunUntilIdle(); |
319 | 327 |
320 ASSERT_EQ(1u, log.size()); | 328 ASSERT_EQ(1u, log.size()); |
321 EXPECT_EQ(base::File::FILE_OK, log[0]); | 329 EXPECT_EQ(base::File::FILE_OK, log[0]); |
322 EXPECT_EQ(1, observer.list_changed_counter()); | 330 EXPECT_EQ(1, observer.list_changed_counter()); |
323 EXPECT_EQ(0, observer.tag_updated_counter()); | 331 EXPECT_EQ(0, observer.tag_updated_counter()); |
324 | 332 |
325 ObservedEntries* const observed_entries = | 333 ObservedEntries* const observed_entries = |
326 provided_file_system_->GetObservedEntries(); | 334 provided_file_system_->GetObservedEntries(); |
327 ASSERT_EQ(1u, observed_entries->size()); | 335 ASSERT_EQ(1u, observed_entries->size()); |
328 const ObservedEntry& observed_entry = observed_entries->begin()->second; | 336 const ObservedEntry& observed_entry = observed_entries->begin()->second; |
329 EXPECT_EQ(kDirectoryPath, observed_entry.entry_path.value()); | 337 EXPECT_EQ(FILE_PATH_LITERAL(kDirectoryPath), |
| 338 observed_entry.entry_path.value()); |
330 EXPECT_FALSE(observed_entry.recursive); | 339 EXPECT_FALSE(observed_entry.recursive); |
331 EXPECT_EQ("", observed_entry.last_tag); | 340 EXPECT_EQ("", observed_entry.last_tag); |
332 | 341 |
333 provided_file_system_->RemoveObserver(&observer); | 342 provided_file_system_->RemoveObserver(&observer); |
334 } | 343 } |
335 | 344 |
| 345 TEST_F(FileSystemProviderProvidedFileSystemTest, |
| 346 ObserveDirectory_PersistentIllegal) { |
| 347 Log log; |
| 348 Observer observer; |
| 349 |
| 350 // Create a provided file system interface, which does not support a notify |
| 351 // tag, though. |
| 352 const base::FilePath mount_path = |
| 353 util::GetMountPath(profile_.get(), kExtensionId, kFileSystemId); |
| 354 MountOptions mount_options; |
| 355 mount_options.file_system_id = kFileSystemId; |
| 356 mount_options.display_name = kDisplayName; |
| 357 mount_options.supports_notify_tag = false; |
| 358 ProvidedFileSystemInfo file_system_info( |
| 359 kExtensionId, mount_options, mount_path); |
| 360 ProvidedFileSystem simple_provided_file_system(profile_.get(), |
| 361 file_system_info); |
| 362 simple_provided_file_system.SetEventRouterForTesting(event_router_.get()); |
| 363 simple_provided_file_system.SetNotificationManagerForTesting( |
| 364 make_scoped_ptr(new StubNotificationManager)); |
| 365 |
| 366 simple_provided_file_system.AddObserver(&observer); |
| 367 |
| 368 simple_provided_file_system.ObserveDirectory( |
| 369 GURL(kOrigin), |
| 370 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
| 371 false /* recursive */, |
| 372 true /* persistent */, |
| 373 base::Bind(&LogStatus, base::Unretained(&log))); |
| 374 base::RunLoop().RunUntilIdle(); |
| 375 |
| 376 ASSERT_EQ(1u, log.size()); |
| 377 EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION, log[0]); |
| 378 EXPECT_EQ(0, observer.list_changed_counter()); |
| 379 EXPECT_EQ(0, observer.tag_updated_counter()); |
| 380 |
| 381 simple_provided_file_system.RemoveObserver(&observer); |
| 382 } |
| 383 |
336 TEST_F(FileSystemProviderProvidedFileSystemTest, ObserveDirectory_Exists) { | 384 TEST_F(FileSystemProviderProvidedFileSystemTest, ObserveDirectory_Exists) { |
337 Observer observer; | 385 Observer observer; |
338 provided_file_system_->AddObserver(&observer); | 386 provided_file_system_->AddObserver(&observer); |
339 | 387 |
340 { | 388 { |
341 // First observe a directory not recursively. | 389 // First observe a directory not recursively. |
342 Log log; | 390 Log log; |
343 provided_file_system_->ObserveDirectory( | 391 provided_file_system_->ObserveDirectory( |
| 392 GURL(kOrigin), |
344 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 393 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
345 false /* recursive */, | 394 false /* recursive */, |
| 395 true /* persistent */, |
346 base::Bind(&LogStatus, base::Unretained(&log))); | 396 base::Bind(&LogStatus, base::Unretained(&log))); |
347 base::RunLoop().RunUntilIdle(); | 397 base::RunLoop().RunUntilIdle(); |
348 | 398 |
349 ASSERT_EQ(1u, log.size()); | 399 ASSERT_EQ(1u, log.size()); |
350 EXPECT_EQ(base::File::FILE_OK, log[0]); | 400 EXPECT_EQ(base::File::FILE_OK, log[0]); |
351 EXPECT_EQ(1, observer.list_changed_counter()); | 401 EXPECT_EQ(1, observer.list_changed_counter()); |
352 EXPECT_EQ(0, observer.tag_updated_counter()); | 402 EXPECT_EQ(0, observer.tag_updated_counter()); |
| 403 |
| 404 ObservedEntries* const observed_entries = |
| 405 provided_file_system_->GetObservedEntries(); |
| 406 ASSERT_TRUE(observed_entries); |
| 407 ASSERT_EQ(1u, observed_entries->size()); |
| 408 const auto& observed_entry_it = observed_entries->find( |
| 409 base::FilePath(FILE_PATH_LITERAL(kDirectoryPath))); |
| 410 ASSERT_NE(observed_entries->end(), observed_entry_it); |
| 411 |
| 412 EXPECT_EQ(1u, observed_entry_it->second.subscribers.size()); |
| 413 const auto& subscriber_it = |
| 414 observed_entry_it->second.subscribers.find(GURL(kOrigin)); |
| 415 ASSERT_NE(observed_entry_it->second.subscribers.end(), subscriber_it); |
| 416 EXPECT_EQ(kOrigin, subscriber_it->first.spec()); |
| 417 EXPECT_EQ(kOrigin, subscriber_it->second.origin.spec()); |
| 418 EXPECT_TRUE(subscriber_it->second.persistent); |
353 } | 419 } |
354 | 420 |
355 { | 421 { |
356 // Create another non-recursive observer. That should fail. | 422 // Create another non-recursive observer. That should fail. |
357 Log log; | 423 Log log; |
358 provided_file_system_->ObserveDirectory( | 424 provided_file_system_->ObserveDirectory( |
| 425 GURL(kOrigin), |
359 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 426 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
360 false /* recursive */, | 427 false /* recursive */, |
| 428 true /* persistent */, |
361 base::Bind(&LogStatus, base::Unretained(&log))); | 429 base::Bind(&LogStatus, base::Unretained(&log))); |
362 base::RunLoop().RunUntilIdle(); | 430 base::RunLoop().RunUntilIdle(); |
363 | 431 |
364 ASSERT_EQ(1u, log.size()); | 432 ASSERT_EQ(1u, log.size()); |
365 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, log[0]); | 433 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, log[0]); |
366 EXPECT_EQ(1, observer.list_changed_counter()); // No changes on the list. | 434 EXPECT_EQ(1, observer.list_changed_counter()); // No changes on the list. |
367 EXPECT_EQ(0, observer.tag_updated_counter()); | 435 EXPECT_EQ(0, observer.tag_updated_counter()); |
368 } | 436 } |
369 | 437 |
370 { | 438 { |
371 // Create another observer on the same path, but a recursive one. That | 439 // Lastly, create another recursive observer. That should fail, too. |
372 // should | |
373 // succeed. | |
374 Log log; | 440 Log log; |
375 provided_file_system_->ObserveDirectory( | 441 provided_file_system_->ObserveDirectory( |
| 442 GURL(kOrigin), |
376 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 443 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
377 true /* recursive */, | 444 true /* recursive */, |
| 445 true /* persistent */, |
| 446 base::Bind(&LogStatus, base::Unretained(&log))); |
| 447 base::RunLoop().RunUntilIdle(); |
| 448 |
| 449 ASSERT_EQ(1u, log.size()); |
| 450 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, log[0]); |
| 451 EXPECT_EQ(1, observer.list_changed_counter()); // No changes on the list. |
| 452 EXPECT_EQ(0, observer.tag_updated_counter()); |
| 453 } |
| 454 |
| 455 provided_file_system_->RemoveObserver(&observer); |
| 456 } |
| 457 |
| 458 TEST_F(FileSystemProviderProvidedFileSystemTest, |
| 459 ObserveDirectory_MultipleOrigins) { |
| 460 Observer observer; |
| 461 provided_file_system_->AddObserver(&observer); |
| 462 |
| 463 { |
| 464 // First observe a directory not recursively. |
| 465 Log log; |
| 466 provided_file_system_->ObserveDirectory( |
| 467 GURL(kOrigin), |
| 468 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
| 469 false /* recursive */, |
| 470 false /* persistent */, |
| 471 base::Bind(&LogStatus, base::Unretained(&log))); |
| 472 base::RunLoop().RunUntilIdle(); |
| 473 |
| 474 ASSERT_EQ(1u, log.size()); |
| 475 EXPECT_EQ(base::File::FILE_OK, log[0]); |
| 476 EXPECT_EQ(1, observer.list_changed_counter()); |
| 477 EXPECT_EQ(0, observer.tag_updated_counter()); |
| 478 |
| 479 ObservedEntries* const observed_entries = |
| 480 provided_file_system_->GetObservedEntries(); |
| 481 ASSERT_TRUE(observed_entries); |
| 482 ASSERT_EQ(1u, observed_entries->size()); |
| 483 const auto& observed_entry_it = observed_entries->find( |
| 484 base::FilePath(FILE_PATH_LITERAL(kDirectoryPath))); |
| 485 ASSERT_NE(observed_entries->end(), observed_entry_it); |
| 486 |
| 487 EXPECT_EQ(1u, observed_entry_it->second.subscribers.size()); |
| 488 const auto& subscriber_it = |
| 489 observed_entry_it->second.subscribers.find(GURL(kOrigin)); |
| 490 ASSERT_NE(observed_entry_it->second.subscribers.end(), subscriber_it); |
| 491 EXPECT_EQ(kOrigin, subscriber_it->first.spec()); |
| 492 EXPECT_EQ(kOrigin, subscriber_it->second.origin.spec()); |
| 493 EXPECT_FALSE(subscriber_it->second.persistent); |
| 494 } |
| 495 |
| 496 { |
| 497 // Create another observer, but recursive and with a different origin. |
| 498 Log log; |
| 499 provided_file_system_->ObserveDirectory( |
| 500 GURL(kAnotherOrigin), |
| 501 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
| 502 false /* recursive */, |
| 503 true /* persistent */, |
378 base::Bind(&LogStatus, base::Unretained(&log))); | 504 base::Bind(&LogStatus, base::Unretained(&log))); |
379 base::RunLoop().RunUntilIdle(); | 505 base::RunLoop().RunUntilIdle(); |
380 | 506 |
381 ASSERT_EQ(1u, log.size()); | 507 ASSERT_EQ(1u, log.size()); |
382 EXPECT_EQ(base::File::FILE_OK, log[0]); | 508 EXPECT_EQ(base::File::FILE_OK, log[0]); |
383 EXPECT_EQ(2, observer.list_changed_counter()); | 509 EXPECT_EQ(2, observer.list_changed_counter()); |
384 EXPECT_EQ(0, observer.tag_updated_counter()); | 510 EXPECT_EQ(0, observer.tag_updated_counter()); |
385 | 511 |
386 ObservedEntries* const observed_entries = | 512 ObservedEntries* const observed_entries = |
387 provided_file_system_->GetObservedEntries(); | 513 provided_file_system_->GetObservedEntries(); |
| 514 ASSERT_TRUE(observed_entries); |
388 ASSERT_EQ(1u, observed_entries->size()); | 515 ASSERT_EQ(1u, observed_entries->size()); |
389 const ObservedEntry& observed_entry = observed_entries->begin()->second; | 516 const auto& observed_entry_it = observed_entries->find( |
390 EXPECT_EQ(kDirectoryPath, observed_entry.entry_path.value()); | 517 base::FilePath(FILE_PATH_LITERAL(kDirectoryPath))); |
391 EXPECT_TRUE(observed_entry.recursive); | 518 ASSERT_NE(observed_entries->end(), observed_entry_it); |
392 EXPECT_EQ("", observed_entry.last_tag); | 519 |
| 520 EXPECT_EQ(2u, observed_entry_it->second.subscribers.size()); |
| 521 const auto& subscriber_it = |
| 522 observed_entry_it->second.subscribers.find(GURL(kOrigin)); |
| 523 ASSERT_NE(observed_entry_it->second.subscribers.end(), subscriber_it); |
| 524 EXPECT_EQ(kOrigin, subscriber_it->first.spec()); |
| 525 EXPECT_EQ(kOrigin, subscriber_it->second.origin.spec()); |
| 526 EXPECT_FALSE(subscriber_it->second.persistent); |
393 } | 527 } |
394 | 528 |
395 { | 529 { |
396 // Lastly, create another recursive observer. That should fail, too. | 530 // Unobserve the second one gracefully. |
397 Log log; | 531 Log log; |
398 provided_file_system_->ObserveDirectory( | 532 provided_file_system_->UnobserveEntry( |
| 533 GURL(kAnotherOrigin), |
399 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 534 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
400 true /* recursive */, | |
401 base::Bind(&LogStatus, base::Unretained(&log))); | 535 base::Bind(&LogStatus, base::Unretained(&log))); |
402 base::RunLoop().RunUntilIdle(); | 536 base::RunLoop().RunUntilIdle(); |
403 | 537 |
404 ASSERT_EQ(1u, log.size()); | 538 ASSERT_EQ(1u, log.size()); |
405 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, log[0]); | 539 EXPECT_EQ(base::File::FILE_OK, log[0]); |
406 EXPECT_EQ(2, observer.list_changed_counter()); // No changes on the list. | 540 EXPECT_EQ(3, observer.list_changed_counter()); |
407 EXPECT_EQ(0, observer.tag_updated_counter()); | 541 EXPECT_EQ(0, observer.tag_updated_counter()); |
| 542 |
| 543 ObservedEntries* const observed_entries = |
| 544 provided_file_system_->GetObservedEntries(); |
| 545 ASSERT_TRUE(observed_entries); |
| 546 EXPECT_EQ(1u, observed_entries->size()); |
| 547 const auto& observed_entry_it = observed_entries->find( |
| 548 base::FilePath(FILE_PATH_LITERAL(kDirectoryPath))); |
| 549 ASSERT_NE(observed_entries->end(), observed_entry_it); |
| 550 |
| 551 EXPECT_EQ(1u, observed_entry_it->second.subscribers.size()); |
| 552 const auto& subscriber_it = |
| 553 observed_entry_it->second.subscribers.find(GURL(kOrigin)); |
| 554 ASSERT_NE(observed_entry_it->second.subscribers.end(), subscriber_it); |
| 555 EXPECT_EQ(kOrigin, subscriber_it->first.spec()); |
| 556 EXPECT_EQ(kOrigin, subscriber_it->second.origin.spec()); |
| 557 EXPECT_FALSE(subscriber_it->second.persistent); |
408 } | 558 } |
409 | 559 |
410 provided_file_system_->RemoveObserver(&observer); | 560 provided_file_system_->RemoveObserver(&observer); |
411 } | 561 } |
412 | 562 |
413 TEST_F(FileSystemProviderProvidedFileSystemTest, UnobserveEntry) { | 563 TEST_F(FileSystemProviderProvidedFileSystemTest, UnobserveEntry) { |
414 Observer observer; | 564 Observer observer; |
415 provided_file_system_->AddObserver(&observer); | 565 provided_file_system_->AddObserver(&observer); |
416 | 566 |
417 { | 567 { |
418 // First, confirm that unobserving an entry which is not observed, results | 568 // First, confirm that unobserving an entry which is not observed, results |
419 // in an error. | 569 // in an error. |
420 Log log; | 570 Log log; |
421 provided_file_system_->UnobserveEntry( | 571 provided_file_system_->UnobserveEntry( |
| 572 GURL(kOrigin), |
422 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 573 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
423 base::Bind(&LogStatus, base::Unretained(&log))); | 574 base::Bind(&LogStatus, base::Unretained(&log))); |
424 base::RunLoop().RunUntilIdle(); | 575 base::RunLoop().RunUntilIdle(); |
425 | 576 |
426 ASSERT_EQ(1u, log.size()); | 577 ASSERT_EQ(1u, log.size()); |
427 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, log[0]); | 578 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, log[0]); |
428 EXPECT_EQ(0, observer.list_changed_counter()); | 579 EXPECT_EQ(0, observer.list_changed_counter()); |
429 EXPECT_EQ(0, observer.tag_updated_counter()); | 580 EXPECT_EQ(0, observer.tag_updated_counter()); |
430 } | 581 } |
431 | 582 |
432 { | 583 { |
433 // Observe a directory not recursively. | 584 // Observe a directory not recursively. |
434 Log log; | 585 Log log; |
435 provided_file_system_->ObserveDirectory( | 586 provided_file_system_->ObserveDirectory( |
| 587 GURL(kOrigin), |
436 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 588 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
437 false /* recursive */, | 589 false /* recursive */, |
| 590 true /* persistent */, |
438 base::Bind(&LogStatus, base::Unretained(&log))); | 591 base::Bind(&LogStatus, base::Unretained(&log))); |
439 base::RunLoop().RunUntilIdle(); | 592 base::RunLoop().RunUntilIdle(); |
440 | 593 |
441 ASSERT_EQ(1u, log.size()); | 594 ASSERT_EQ(1u, log.size()); |
442 EXPECT_EQ(base::File::FILE_OK, log[0]); | 595 EXPECT_EQ(base::File::FILE_OK, log[0]); |
443 EXPECT_EQ(1, observer.list_changed_counter()); | 596 EXPECT_EQ(1, observer.list_changed_counter()); |
444 EXPECT_EQ(0, observer.tag_updated_counter()); | 597 EXPECT_EQ(0, observer.tag_updated_counter()); |
445 | 598 |
446 ObservedEntries* const observed_entries = | 599 ObservedEntries* const observed_entries = |
447 provided_file_system_->GetObservedEntries(); | 600 provided_file_system_->GetObservedEntries(); |
448 EXPECT_EQ(1u, observed_entries->size()); | 601 EXPECT_EQ(1u, observed_entries->size()); |
449 } | 602 } |
450 | 603 |
451 { | 604 { |
452 // Unobserve it gracefully. | 605 // Unobserve it gracefully. |
453 Log log; | 606 Log log; |
454 provided_file_system_->UnobserveEntry( | 607 provided_file_system_->UnobserveEntry( |
| 608 GURL(kOrigin), |
455 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 609 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
456 base::Bind(&LogStatus, base::Unretained(&log))); | 610 base::Bind(&LogStatus, base::Unretained(&log))); |
457 base::RunLoop().RunUntilIdle(); | 611 base::RunLoop().RunUntilIdle(); |
458 | 612 |
459 ASSERT_EQ(1u, log.size()); | 613 ASSERT_EQ(1u, log.size()); |
460 EXPECT_EQ(base::File::FILE_OK, log[0]); | 614 EXPECT_EQ(base::File::FILE_OK, log[0]); |
461 EXPECT_EQ(2, observer.list_changed_counter()); | 615 EXPECT_EQ(2, observer.list_changed_counter()); |
462 EXPECT_EQ(0, observer.tag_updated_counter()); | 616 EXPECT_EQ(0, observer.tag_updated_counter()); |
463 | 617 |
464 ObservedEntries* const observed_entries = | 618 ObservedEntries* const observed_entries = |
465 provided_file_system_->GetObservedEntries(); | 619 provided_file_system_->GetObservedEntries(); |
466 EXPECT_EQ(0u, observed_entries->size()); | 620 EXPECT_EQ(0u, observed_entries->size()); |
467 } | 621 } |
468 | 622 |
469 { | 623 { |
470 // Confirm that it's possible to observe it again. | 624 // Confirm that it's possible to observe it again. |
471 Log log; | 625 Log log; |
472 provided_file_system_->ObserveDirectory( | 626 provided_file_system_->ObserveDirectory( |
| 627 GURL(kOrigin), |
473 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 628 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
474 false /* recursive */, | 629 false /* recursive */, |
| 630 true /* persistent */, |
475 base::Bind(&LogStatus, base::Unretained(&log))); | 631 base::Bind(&LogStatus, base::Unretained(&log))); |
476 base::RunLoop().RunUntilIdle(); | 632 base::RunLoop().RunUntilIdle(); |
477 | 633 |
478 ASSERT_EQ(1u, log.size()); | 634 ASSERT_EQ(1u, log.size()); |
479 EXPECT_EQ(base::File::FILE_OK, log[0]); | 635 EXPECT_EQ(base::File::FILE_OK, log[0]); |
480 EXPECT_EQ(3, observer.list_changed_counter()); | 636 EXPECT_EQ(3, observer.list_changed_counter()); |
481 EXPECT_EQ(0, observer.tag_updated_counter()); | 637 EXPECT_EQ(0, observer.tag_updated_counter()); |
482 | 638 |
483 ObservedEntries* const observed_entries = | 639 ObservedEntries* const observed_entries = |
484 provided_file_system_->GetObservedEntries(); | 640 provided_file_system_->GetObservedEntries(); |
485 EXPECT_EQ(1u, observed_entries->size()); | 641 EXPECT_EQ(1u, observed_entries->size()); |
486 } | 642 } |
487 | 643 |
488 { | 644 { |
489 // Finally, unobserve it, but with an error from extension. That should | 645 // Finally, unobserve it, but with an error from extension. That should |
490 // result | 646 // result in a removed observer, anyway. The error code should not be |
491 // in a removed observer, anyway. | 647 // passed. |
492 event_router_->set_reply_result(base::File::FILE_ERROR_FAILED); | 648 event_router_->set_reply_result(base::File::FILE_ERROR_FAILED); |
493 | 649 |
494 Log log; | 650 Log log; |
495 provided_file_system_->UnobserveEntry( | 651 provided_file_system_->UnobserveEntry( |
| 652 GURL(kOrigin), |
496 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 653 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
497 base::Bind(&LogStatus, base::Unretained(&log))); | 654 base::Bind(&LogStatus, base::Unretained(&log))); |
498 base::RunLoop().RunUntilIdle(); | 655 base::RunLoop().RunUntilIdle(); |
499 | 656 |
500 ASSERT_EQ(1u, log.size()); | 657 ASSERT_EQ(1u, log.size()); |
501 EXPECT_EQ(base::File::FILE_ERROR_FAILED, log[0]); | 658 EXPECT_EQ(base::File::FILE_OK, log[0]); |
502 EXPECT_EQ(4, observer.list_changed_counter()); | 659 EXPECT_EQ(4, observer.list_changed_counter()); |
503 EXPECT_EQ(0, observer.tag_updated_counter()); | 660 EXPECT_EQ(0, observer.tag_updated_counter()); |
504 | 661 |
505 ObservedEntries* const observed_entries = | 662 ObservedEntries* const observed_entries = |
506 provided_file_system_->GetObservedEntries(); | 663 provided_file_system_->GetObservedEntries(); |
507 EXPECT_EQ(0u, observed_entries->size()); | 664 EXPECT_EQ(0u, observed_entries->size()); |
508 } | 665 } |
509 | 666 |
510 provided_file_system_->RemoveObserver(&observer); | 667 provided_file_system_->RemoveObserver(&observer); |
511 } | 668 } |
512 | 669 |
513 TEST_F(FileSystemProviderProvidedFileSystemTest, Notify) { | 670 TEST_F(FileSystemProviderProvidedFileSystemTest, Notify) { |
514 Observer observer; | 671 Observer observer; |
515 provided_file_system_->AddObserver(&observer); | 672 provided_file_system_->AddObserver(&observer); |
516 | 673 |
517 { | 674 { |
518 // Observe a directory. | 675 // Observe a directory. |
519 Log log; | 676 Log log; |
520 provided_file_system_->ObserveDirectory( | 677 provided_file_system_->ObserveDirectory( |
| 678 GURL(kOrigin), |
521 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 679 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
522 false /* recursive */, | 680 false /* recursive */, |
| 681 true /* persistent */, |
523 base::Bind(&LogStatus, base::Unretained(&log))); | 682 base::Bind(&LogStatus, base::Unretained(&log))); |
524 base::RunLoop().RunUntilIdle(); | 683 base::RunLoop().RunUntilIdle(); |
525 | 684 |
526 ASSERT_EQ(1u, log.size()); | 685 ASSERT_EQ(1u, log.size()); |
527 EXPECT_EQ(base::File::FILE_OK, log[0]); | 686 EXPECT_EQ(base::File::FILE_OK, log[0]); |
528 EXPECT_EQ(1, observer.list_changed_counter()); | 687 EXPECT_EQ(1, observer.list_changed_counter()); |
529 EXPECT_EQ(0, observer.tag_updated_counter()); | 688 EXPECT_EQ(0, observer.tag_updated_counter()); |
530 | 689 |
531 ObservedEntries* const observed_entries = | 690 ObservedEntries* const observed_entries = |
532 provided_file_system_->GetObservedEntries(); | 691 provided_file_system_->GetObservedEntries(); |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
600 EXPECT_EQ(0u, observed_entries->size()); | 759 EXPECT_EQ(0u, observed_entries->size()); |
601 EXPECT_EQ(2, observer.list_changed_counter()); | 760 EXPECT_EQ(2, observer.list_changed_counter()); |
602 EXPECT_EQ(2, observer.tag_updated_counter()); | 761 EXPECT_EQ(2, observer.tag_updated_counter()); |
603 } | 762 } |
604 | 763 |
605 provided_file_system_->RemoveObserver(&observer); | 764 provided_file_system_->RemoveObserver(&observer); |
606 } | 765 } |
607 | 766 |
608 } // namespace file_system_provider | 767 } // namespace file_system_provider |
609 } // namespace chromeos | 768 } // namespace chromeos |
OLD | NEW |