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
21namespace chromeos {
22namespace file_system_provider {
23namespace {
24
25// Logs calls of the success and error callbacks on requests.
26class 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.
108class 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.
146class 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
248class 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
261TEST_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
283TEST_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
351TEST_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
420TEST_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
480TEST_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
527TEST_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
569TEST_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
586TEST_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
634TEST_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