src/chrome/browser/chromeos/file_system_provider/request_manager_unittest.cc

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