Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(219)

Side by Side Diff: chrome/browser/chromeos/file_system_provider/provided_file_system_unittest.cc

Issue 642023003: [fsp] Allow to create multiple observers for a directory, up to one per origin. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698