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 3 // found in the LICENSE file. 4 5 #include <string> 6 #include <vector> 7 8 #include "base/bind.h" 9 #include "base/callback.h" 10 #include "base/files/file.h" 11 #include "base/files/file_path.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/memory/scoped_vector.h" 14 #include "base/memory/weak_ptr.h" 15 #include "base/run_loop.h" 16 #include "chrome/browser/chromeos/file_system_provider/request_manager.h" 17 #include "chrome/browser/chromeos/file_system_provider/request_value.h" 18 #include "content/public/test/test_browser_thread_bundle.h" 19 #include "testing/gtest/include/gtest/gtest.h" 20 21 namespace chromeos { 22 namespace file_system_provider { 23 namespace { 24 25 // Logs calls of the success and error callbacks on requests. 26 class EventLogger { 27 public: 28 class ExecuteEvent { 29 public: 30 explicit ExecuteEvent(int request_id) : request_id_(request_id) {} 31 virtual ~ExecuteEvent() {} 32 33 int request_id() { return request_id_; } 34 35 private: 36 int request_id_; 37 }; 38 39 class SuccessEvent { 40 public: 41 SuccessEvent(int request_id, scoped_ptr<RequestValue> result, bool has_more) 42 : request_id_(request_id), 43 result_(result.Pass()), 44 has_more_(has_more) {} 45 virtual ~SuccessEvent() {} 46 47 int request_id() { return request_id_; } 48 RequestValue* result() { return result_.get(); } 49 bool has_more() { return has_more_; } 50 51 private: 52 int request_id_; 53 scoped_ptr<RequestValue> result_; 54 bool has_more_; 55 }; 56 57 class ErrorEvent { 58 public: 59 ErrorEvent(int request_id, base::File::Error error) 60 : request_id_(request_id), error_(error) {} 61 virtual ~ErrorEvent() {} 62 63 int request_id() { return request_id_; } 64 base::File::Error error() { return error_; } 65 66 private: 67 int request_id_; 68 base::File::Error error_; 69 }; 70 71 EventLogger() : weak_ptr_factory_(this) {} 72 virtual ~EventLogger() {} 73 74 void OnExecute(int request_id) { 75 execute_events_.push_back(new ExecuteEvent(request_id)); 76 } 77 78 void OnSuccess(int request_id, 79 scoped_ptr<RequestValue> result, 80 bool has_more) { 81 success_events_.push_back( 82 new SuccessEvent(request_id, result.Pass(), has_more)); 83 } 84 85 void OnError(int request_id, base::File::Error error) { 86 error_events_.push_back(new ErrorEvent(request_id, error)); 87 } 88 89 ScopedVector<ExecuteEvent>& execute_events() { return execute_events_; } 90 ScopedVector<SuccessEvent>& success_events() { return success_events_; } 91 ScopedVector<ErrorEvent>& error_events() { return error_events_; } 92 93 base::WeakPtr<EventLogger> GetWeakPtr() { 94 return weak_ptr_factory_.GetWeakPtr(); 95 } 96 97 private: 98 ScopedVector<ExecuteEvent> execute_events_; 99 ScopedVector<SuccessEvent> success_events_; 100 ScopedVector<ErrorEvent> error_events_; 101 base::WeakPtrFactory<EventLogger> weak_ptr_factory_; 102 103 DISALLOW_COPY_AND_ASSIGN(EventLogger); 104 }; 105 106 // Fake handler, which forwards callbacks to the logger. The handler is owned 107 // by a request manager, however the logger is owned by tests. 108 class FakeHandler : public RequestManager::HandlerInterface { 109 public: 110 // The handler can outlive the passed logger, so using a weak pointer. The 111 // |execute_reply| value will be returned for the Execute() call. 112 FakeHandler(base::WeakPtr<EventLogger> logger, bool execute_reply) 113 : logger_(logger), execute_reply_(execute_reply) {} 114 115 // RequestManager::Handler overrides. 116 virtual bool Execute(int request_id) OVERRIDE { 117 if (logger_.get()) 118 logger_->OnExecute(request_id); 119 120 return execute_reply_; 121 } 122 123 // RequestManager::Handler overrides. 124 virtual void OnSuccess(int request_id, 125 scoped_ptr<RequestValue> result, 126 bool has_more) OVERRIDE { 127 if (logger_.get()) 128 logger_->OnSuccess(request_id, result.Pass(), has_more); 129 } 130 131 // RequestManager::Handler overrides. 132 virtual void OnError(int request_id, base::File::Error error) OVERRIDE { 133 if (logger_.get()) 134 logger_->OnError(request_id, error); 135 } 136 137 virtual ~FakeHandler() {} 138 139 private: 140 base::WeakPtr<EventLogger> logger_; 141 bool execute_reply_; 142 DISALLOW_COPY_AND_ASSIGN(FakeHandler); 143 }; 144 145 // Observer the request manager for request events. 146 class RequestObserver : public RequestManager::Observer { 147 public: 148 class Event { 149 public: 150 explicit Event(int request_id) : request_id_(request_id) {} 151 virtual ~Event() {} 152 int request_id() const { return request_id_; } 153 154 private: 155 int request_id_; 156 }; 157 158 class CreatedEvent : public Event { 159 public: 160 CreatedEvent(int request_id, RequestType type) 161 : Event(request_id), type_(type) {} 162 virtual ~CreatedEvent() {} 163 164 RequestType type() const { return type_; } 165 166 private: 167 RequestType type_; 168 }; 169 170 class FulfilledEvent : public Event { 171 public: 172 FulfilledEvent(int request_id, bool has_more) 173 : Event(request_id), has_more_(has_more) {} 174 virtual ~FulfilledEvent() {} 175 176 bool has_more() const { return has_more_; } 177 178 private: 179 bool has_more_; 180 }; 181 182 class RejectedEvent : public Event { 183 public: 184 RejectedEvent(int request_id, base::File::Error error) 185 : Event(request_id), error_(error) {} 186 virtual ~RejectedEvent() {} 187 188 base::File::Error error() const { return error_; } 189 190 private: 191 base::File::Error error_; 192 }; 193 194 RequestObserver() {} 195 virtual ~RequestObserver() {} 196 197 // RequestManager::Observer overrides. 198 virtual void OnRequestCreated(int request_id, RequestType type) OVERRIDE { 199 created_.push_back(CreatedEvent(request_id, type)); 200 } 201 202 // RequestManager::Observer overrides. 203 virtual void OnRequestDestroyed(int request_id) OVERRIDE { 204 destroyed_.push_back(Event(request_id)); 205 } 206 207 // RequestManager::Observer overrides. 208 virtual void OnRequestExecuted(int request_id) OVERRIDE { 209 executed_.push_back(Event(request_id)); 210 } 211 212 // RequestManager::Observer overrides. 213 virtual void OnRequestFulfilled(int request_id, bool has_more) OVERRIDE { 214 fulfilled_.push_back(FulfilledEvent(request_id, has_more)); 215 } 216 217 // RequestManager::Observer overrides. 218 virtual void OnRequestRejected(int request_id, 219 base::File::Error error) OVERRIDE { 220 rejected_.push_back(RejectedEvent(request_id, error)); 221 } 222 223 // RequestManager::Observer overrides. 224 virtual void OnRequestTimeouted(int request_id) OVERRIDE { 225 timeouted_.push_back(Event(request_id)); 226 } 227 228 const std::vector<CreatedEvent>& created() const { return created_; } 229 const std::vector<Event>& destroyed() const { return destroyed_; } 230 const std::vector<Event>& executed() const { return executed_; } 231 const std::vector<FulfilledEvent>& fulfilled() const { return fulfilled_; } 232 const std::vector<RejectedEvent>& rejected() const { return rejected_; } 233 const std::vector<Event>& timeouted() const { return timeouted_; } 234 235 private: 236 std::vector<CreatedEvent> created_; 237 std::vector<Event> destroyed_; 238 std::vector<Event> executed_; 239 std::vector<FulfilledEvent> fulfilled_; 240 std::vector<RejectedEvent> rejected_; 241 std::vector<Event> timeouted_; 242 243 DISALLOW_COPY_AND_ASSIGN(RequestObserver); 244 }; 245 246 } // namespace 247 248 class FileSystemProviderRequestManagerTest : public testing::Test { 249 protected: 250 FileSystemProviderRequestManagerTest() {} 251 virtual ~FileSystemProviderRequestManagerTest() {} 252 253 virtual void SetUp() OVERRIDE { 254 request_manager_.reset(new RequestManager()); 255 } 256 257 content::TestBrowserThreadBundle thread_bundle_; 258 scoped_ptr<RequestManager> request_manager_; 259 }; 260 261 TEST_F(FileSystemProviderRequestManagerTest, CreateFailure) { 262 EventLogger logger; 263 RequestObserver observer; 264 request_manager_->AddObserver(&observer); 265 266 const int request_id = request_manager_->CreateRequest( 267 TESTING, 268 make_scoped_ptr<RequestManager::HandlerInterface>( 269 new FakeHandler(logger.GetWeakPtr(), false /* execute_reply */))); 270 271 EXPECT_EQ(0, request_id); 272 EXPECT_EQ(0u, logger.success_events().size()); 273 EXPECT_EQ(0u, logger.error_events().size()); 274 275 EXPECT_EQ(1u, observer.created().size()); 276 EXPECT_EQ(TESTING, observer.created()[0].type()); 277 EXPECT_EQ(1u, observer.destroyed().size()); 278 EXPECT_EQ(0u, observer.executed().size()); 279 280 request_manager_->RemoveObserver(&observer); 281 } 282 283 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) { 284 EventLogger logger; 285 RequestObserver observer; 286 request_manager_->AddObserver(&observer); 287 288 const int request_id = request_manager_->CreateRequest( 289 TESTING, 290 make_scoped_ptr<RequestManager::HandlerInterface>( 291 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); 292 293 EXPECT_EQ(1, request_id); 294 EXPECT_EQ(0u, logger.success_events().size()); 295 EXPECT_EQ(0u, logger.error_events().size()); 296 297 ASSERT_EQ(1u, observer.created().size()); 298 EXPECT_EQ(request_id, observer.created()[0].request_id()); 299 EXPECT_EQ(TESTING, observer.created()[0].type()); 300 301 ASSERT_EQ(1u, observer.executed().size()); 302 EXPECT_EQ(request_id, observer.executed()[0].request_id()); 303 304 scoped_ptr<RequestValue> response( 305 RequestValue::CreateForTesting("i-like-vanilla")); 306 const bool has_more = false; 307 308 bool result = 309 request_manager_->FulfillRequest(request_id, response.Pass(), has_more); 310 EXPECT_TRUE(result); 311 312 ASSERT_EQ(1u, observer.fulfilled().size()); 313 EXPECT_EQ(request_id, observer.fulfilled()[0].request_id()); 314 EXPECT_FALSE(observer.fulfilled()[0].has_more()); 315 316 // Validate if the callback has correct arguments. 317 ASSERT_EQ(1u, logger.success_events().size()); 318 EXPECT_EQ(0u, logger.error_events().size()); 319 EventLogger::SuccessEvent* event = logger.success_events()[0]; 320 ASSERT_TRUE(event->result()); 321 const std::string* response_test_string = event->result()->testing_params(); 322 ASSERT_TRUE(response_test_string); 323 EXPECT_EQ("i-like-vanilla", *response_test_string); 324 EXPECT_FALSE(event->has_more()); 325 326 // Confirm, that the request is removed. Basically, fulfilling again for the 327 // same request, should fail. 328 { 329 scoped_ptr<RequestValue> response; 330 bool retry = 331 request_manager_->FulfillRequest(request_id, response.Pass(), has_more); 332 EXPECT_FALSE(retry); 333 EXPECT_EQ(1u, observer.fulfilled().size()); 334 } 335 336 // Rejecting should also fail. 337 { 338 bool retry = request_manager_->RejectRequest(request_id, 339 base::File::FILE_ERROR_FAILED); 340 EXPECT_FALSE(retry); 341 EXPECT_EQ(0u, observer.rejected().size()); 342 } 343 344 ASSERT_EQ(1u, observer.destroyed().size()); 345 EXPECT_EQ(request_id, observer.destroyed()[0].request_id()); 346 EXPECT_EQ(0u, observer.timeouted().size()); 347 348 request_manager_->RemoveObserver(&observer); 349 } 350 351 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) { 352 EventLogger logger; 353 RequestObserver observer; 354 request_manager_->AddObserver(&observer); 355 356 const int request_id = request_manager_->CreateRequest( 357 TESTING, 358 make_scoped_ptr<RequestManager::HandlerInterface>( 359 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); 360 361 EXPECT_EQ(1, request_id); 362 EXPECT_EQ(0u, logger.success_events().size()); 363 EXPECT_EQ(0u, logger.error_events().size()); 364 365 ASSERT_EQ(1u, observer.created().size()); 366 EXPECT_EQ(request_id, observer.created()[0].request_id()); 367 EXPECT_EQ(TESTING, observer.created()[0].type()); 368 369 ASSERT_EQ(1u, observer.executed().size()); 370 EXPECT_EQ(request_id, observer.executed()[0].request_id()); 371 372 scoped_ptr<RequestValue> response; 373 const bool has_more = true; 374 375 bool result = 376 request_manager_->FulfillRequest(request_id, response.Pass(), has_more); 377 EXPECT_TRUE(result); 378 379 // Validate if the callback has correct arguments. 380 ASSERT_EQ(1u, logger.success_events().size()); 381 EXPECT_EQ(0u, logger.error_events().size()); 382 EventLogger::SuccessEvent* event = logger.success_events()[0]; 383 EXPECT_FALSE(event->result()); 384 EXPECT_TRUE(event->has_more()); 385 386 ASSERT_EQ(1u, observer.fulfilled().size()); 387 EXPECT_EQ(request_id, observer.fulfilled()[0].request_id()); 388 EXPECT_TRUE(observer.fulfilled()[0].has_more()); 389 390 // Confirm, that the request is not removed (since it has has_more == true). 391 // Basically, fulfilling again for the same request, should not fail. 392 { 393 bool new_has_more = false; 394 bool retry = request_manager_->FulfillRequest( 395 request_id, response.Pass(), new_has_more); 396 EXPECT_TRUE(retry); 397 398 ASSERT_EQ(2u, observer.fulfilled().size()); 399 EXPECT_EQ(request_id, observer.fulfilled()[1].request_id()); 400 EXPECT_FALSE(observer.fulfilled()[1].has_more()); 401 } 402 403 // Since |new_has_more| is false, then the request should be removed. To check 404 // it, try to fulfill again, what should fail. 405 { 406 bool new_has_more = false; 407 bool retry = request_manager_->FulfillRequest( 408 request_id, response.Pass(), new_has_more); 409 EXPECT_FALSE(retry); 410 EXPECT_EQ(0u, observer.rejected().size()); 411 } 412 413 ASSERT_EQ(1u, observer.destroyed().size()); 414 EXPECT_EQ(request_id, observer.destroyed()[0].request_id()); 415 EXPECT_EQ(0u, observer.timeouted().size()); 416 417 request_manager_->RemoveObserver(&observer); 418 } 419 420 TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) { 421 EventLogger logger; 422 RequestObserver observer; 423 request_manager_->AddObserver(&observer); 424 425 const int request_id = request_manager_->CreateRequest( 426 TESTING, 427 make_scoped_ptr<RequestManager::HandlerInterface>( 428 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); 429 430 EXPECT_EQ(1, request_id); 431 EXPECT_EQ(0u, logger.success_events().size()); 432 EXPECT_EQ(0u, logger.error_events().size()); 433 434 ASSERT_EQ(1u, observer.created().size()); 435 EXPECT_EQ(request_id, observer.created()[0].request_id()); 436 EXPECT_EQ(TESTING, observer.created()[0].type()); 437 438 ASSERT_EQ(1u, observer.executed().size()); 439 EXPECT_EQ(request_id, observer.executed()[0].request_id()); 440 441 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; 442 bool result = request_manager_->RejectRequest(request_id, error); 443 EXPECT_TRUE(result); 444 445 // Validate if the callback has correct arguments. 446 ASSERT_EQ(1u, logger.error_events().size()); 447 EXPECT_EQ(0u, logger.success_events().size()); 448 EventLogger::ErrorEvent* event = logger.error_events()[0]; 449 EXPECT_EQ(error, event->error()); 450 451 ASSERT_EQ(1u, observer.rejected().size()); 452 EXPECT_EQ(request_id, observer.rejected()[0].request_id()); 453 EXPECT_EQ(error, observer.rejected()[0].error()); 454 455 // Confirm, that the request is removed. Basically, fulfilling again for the 456 // same request, should fail. 457 { 458 scoped_ptr<RequestValue> response; 459 bool has_more = false; 460 bool retry = 461 request_manager_->FulfillRequest(request_id, response.Pass(), has_more); 462 EXPECT_FALSE(retry); 463 EXPECT_EQ(0u, observer.fulfilled().size()); 464 } 465 466 // Rejecting should also fail. 467 { 468 bool retry = request_manager_->RejectRequest(request_id, error); 469 EXPECT_FALSE(retry); 470 EXPECT_EQ(1u, observer.rejected().size()); 471 } 472 473 ASSERT_EQ(1u, observer.destroyed().size()); 474 EXPECT_EQ(request_id, observer.destroyed()[0].request_id()); 475 EXPECT_EQ(0u, observer.timeouted().size()); 476 477 request_manager_->RemoveObserver(&observer); 478 } 479 480 TEST_F(FileSystemProviderRequestManagerTest, 481 CreateAndFulfillWithWrongRequestId) { 482 EventLogger logger; 483 RequestObserver observer; 484 request_manager_->AddObserver(&observer); 485 486 const int request_id = request_manager_->CreateRequest( 487 TESTING, 488 make_scoped_ptr<RequestManager::HandlerInterface>( 489 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); 490 491 EXPECT_EQ(1, request_id); 492 EXPECT_EQ(0u, logger.success_events().size()); 493 EXPECT_EQ(0u, logger.error_events().size()); 494 495 ASSERT_EQ(1u, observer.created().size()); 496 EXPECT_EQ(request_id, observer.created()[0].request_id()); 497 EXPECT_EQ(TESTING, observer.created()[0].type()); 498 499 ASSERT_EQ(1u, observer.executed().size()); 500 EXPECT_EQ(request_id, observer.executed()[0].request_id()); 501 502 scoped_ptr<RequestValue> response; 503 const bool has_more = true; 504 505 const bool result = request_manager_->FulfillRequest( 506 request_id + 1, response.Pass(), has_more); 507 EXPECT_FALSE(result); 508 509 // Callbacks should not be called. 510 EXPECT_EQ(0u, logger.error_events().size()); 511 EXPECT_EQ(0u, logger.success_events().size()); 512 513 EXPECT_EQ(0u, observer.fulfilled().size()); 514 EXPECT_EQ(request_id, observer.executed()[0].request_id()); 515 516 // Confirm, that the request hasn't been removed, by fulfilling it correctly. 517 { 518 const bool retry = 519 request_manager_->FulfillRequest(request_id, response.Pass(), has_more); 520 EXPECT_TRUE(retry); 521 EXPECT_EQ(1u, observer.fulfilled().size()); 522 } 523 524 request_manager_->RemoveObserver(&observer); 525 } 526 527 TEST_F(FileSystemProviderRequestManagerTest, 528 CreateAndRejectWithWrongRequestId) { 529 EventLogger logger; 530 RequestObserver observer; 531 request_manager_->AddObserver(&observer); 532 533 const int request_id = request_manager_->CreateRequest( 534 TESTING, 535 make_scoped_ptr<RequestManager::HandlerInterface>( 536 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); 537 538 EXPECT_EQ(1, request_id); 539 EXPECT_EQ(0u, logger.success_events().size()); 540 EXPECT_EQ(0u, logger.error_events().size()); 541 542 ASSERT_EQ(1u, observer.created().size()); 543 EXPECT_EQ(request_id, observer.created()[0].request_id()); 544 EXPECT_EQ(TESTING, observer.created()[0].type()); 545 546 ASSERT_EQ(1u, observer.executed().size()); 547 EXPECT_EQ(request_id, observer.executed()[0].request_id()); 548 549 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; 550 bool result = request_manager_->RejectRequest(request_id + 1, error); 551 EXPECT_FALSE(result); 552 553 // Callbacks should not be called. 554 EXPECT_EQ(0u, logger.error_events().size()); 555 EXPECT_EQ(0u, logger.success_events().size()); 556 557 EXPECT_EQ(0u, observer.rejected().size()); 558 559 // Confirm, that the request hasn't been removed, by rejecting it correctly. 560 { 561 bool retry = request_manager_->RejectRequest(request_id, error); 562 EXPECT_TRUE(retry); 563 EXPECT_EQ(1u, observer.rejected().size()); 564 } 565 566 request_manager_->RemoveObserver(&observer); 567 } 568 569 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) { 570 EventLogger logger; 571 572 const int first_request_id = request_manager_->CreateRequest( 573 TESTING, 574 make_scoped_ptr<RequestManager::HandlerInterface>( 575 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); 576 577 const int second_request_id = request_manager_->CreateRequest( 578 TESTING, 579 make_scoped_ptr<RequestManager::HandlerInterface>( 580 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); 581 582 EXPECT_EQ(1, first_request_id); 583 EXPECT_EQ(2, second_request_id); 584 } 585 586 TEST_F(FileSystemProviderRequestManagerTest, AbortOnDestroy) { 587 EventLogger logger; 588 RequestObserver observer; 589 int request_id; 590 591 { 592 RequestManager request_manager; 593 request_manager.AddObserver(&observer); 594 595 request_id = request_manager.CreateRequest( 596 TESTING, 597 make_scoped_ptr<RequestManager::HandlerInterface>( 598 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); 599 600 EXPECT_EQ(1, request_id); 601 EXPECT_EQ(0u, logger.success_events().size()); 602 EXPECT_EQ(0u, logger.error_events().size()); 603 604 ASSERT_EQ(1u, observer.created().size()); 605 EXPECT_EQ(request_id, observer.created()[0].request_id()); 606 EXPECT_EQ(TESTING, observer.created()[0].type()); 607 608 ASSERT_EQ(1u, observer.executed().size()); 609 EXPECT_EQ(request_id, observer.executed()[0].request_id()); 610 611 EXPECT_EQ(0u, observer.fulfilled().size()); 612 EXPECT_EQ(0u, observer.rejected().size()); 613 EXPECT_EQ(0u, observer.destroyed().size()); 614 EXPECT_EQ(0u, observer.timeouted().size()); 615 616 // Do not remove the observer, to catch events while destructing. 617 } 618 619 // All active requests should be aborted in the destructor of RequestManager. 620 ASSERT_EQ(1u, logger.error_events().size()); 621 EventLogger::ErrorEvent* event = logger.error_events()[0]; 622 EXPECT_EQ(base::File::FILE_ERROR_ABORT, event->error()); 623 624 EXPECT_EQ(0u, logger.success_events().size()); 625 626 EXPECT_EQ(0u, observer.fulfilled().size()); 627 EXPECT_EQ(0u, observer.timeouted().size()); 628 ASSERT_EQ(1u, observer.rejected().size()); 629 EXPECT_EQ(request_id, observer.rejected()[0].request_id()); 630 EXPECT_EQ(base::File::FILE_ERROR_ABORT, observer.rejected()[0].error()); 631 ASSERT_EQ(1u, observer.destroyed().size()); 632 } 633 634 TEST_F(FileSystemProviderRequestManagerTest, AbortOnTimeout) { 635 EventLogger logger; 636 RequestObserver observer; 637 request_manager_->AddObserver(&observer); 638 639 request_manager_->SetTimeoutForTesting(base::TimeDelta::FromSeconds(0)); 640 const int request_id = request_manager_->CreateRequest( 641 TESTING, 642 make_scoped_ptr<RequestManager::HandlerInterface>( 643 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); 644 EXPECT_EQ(1, request_id); 645 EXPECT_EQ(0u, logger.success_events().size()); 646 EXPECT_EQ(0u, logger.error_events().size()); 647 648 ASSERT_EQ(1u, observer.created().size()); 649 EXPECT_EQ(request_id, observer.created()[0].request_id()); 650 EXPECT_EQ(TESTING, observer.created()[0].type()); 651 652 ASSERT_EQ(1u, observer.executed().size()); 653 EXPECT_EQ(request_id, observer.executed()[0].request_id()); 654 655 // Wait until the request is timeouted. 656 base::RunLoop().RunUntilIdle(); 657 658 ASSERT_EQ(1u, logger.error_events().size()); 659 EventLogger::ErrorEvent* event = logger.error_events()[0]; 660 EXPECT_EQ(base::File::FILE_ERROR_ABORT, event->error()); 661 662 ASSERT_EQ(1u, observer.rejected().size()); 663 EXPECT_EQ(request_id, observer.rejected()[0].request_id()); 664 EXPECT_EQ(base::File::FILE_ERROR_ABORT, observer.rejected()[0].error()); 665 ASSERT_EQ(1u, observer.timeouted().size()); 666 EXPECT_EQ(request_id, observer.timeouted()[0].request_id()); 667 ASSERT_EQ(1u, observer.destroyed().size()); 668 EXPECT_EQ(request_id, observer.destroyed()[0].request_id()); 669 670 request_manager_->RemoveObserver(&observer); 671 } 672 673 } // namespace file_system_provider 674 } // namespace chromeos 675
