Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/file_system_provider/request_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/file_system_provider/request_manager.h"
 
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/file_system_provider/notification_manager_interface.h"
 #include "chrome/browser/chromeos/file_system_provider/request_value.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
@@ skipping 54 matching lines @@
     virtual ~ExecuteEvent() {}
 
     int request_id() { return request_id_; }
 
    private:
     int request_id_;
   };
 
   class SuccessEvent {
    public:
-    SuccessEvent(int request_id, scoped_ptr<RequestValue> result, bool has_more)
+    SuccessEvent(int request_id,
+                 std::unique_ptr<RequestValue> result,
+                 bool has_more)
         : request_id_(request_id),
           result_(std::move(result)),
           has_more_(has_more) {}
     virtual ~SuccessEvent() {}
 
     int request_id() { return request_id_; }
     RequestValue* result() { return result_.get(); }
     bool has_more() { return has_more_; }
 
    private:
     int request_id_;
-    scoped_ptr<RequestValue> result_;
+    std::unique_ptr<RequestValue> result_;
     bool has_more_;
   };
 
   class ErrorEvent {
    public:
     ErrorEvent(int request_id,
-               scoped_ptr<RequestValue> result,
+               std::unique_ptr<RequestValue> result,
                base::File::Error error)
         : request_id_(request_id), result_(std::move(result)), error_(error) {}
     virtual ~ErrorEvent() {}
 
     int request_id() { return request_id_; }
     RequestValue* result() { return result_.get(); }
     base::File::Error error() { return error_; }
 
    private:
     int request_id_;
-    scoped_ptr<RequestValue> result_;
+    std::unique_ptr<RequestValue> result_;
     base::File::Error error_;
   };
 
   EventLogger() : weak_ptr_factory_(this) {}
   virtual ~EventLogger() {}
 
   void OnExecute(int request_id) {
     execute_events_.push_back(new ExecuteEvent(request_id));
   }
 
   void OnSuccess(int request_id,
-                 scoped_ptr<RequestValue> result,
+                 std::unique_ptr<RequestValue> result,
                  bool has_more) {
     success_events_.push_back(
         new SuccessEvent(request_id, std::move(result), has_more));
   }
 
   void OnError(int request_id,
-               scoped_ptr<RequestValue> result,
+               std::unique_ptr<RequestValue> result,
                base::File::Error error) {
     error_events_.push_back(
         new ErrorEvent(request_id, std::move(result), error));
   }
 
   ScopedVector<ExecuteEvent>& execute_events() { return execute_events_; }
   ScopedVector<SuccessEvent>& success_events() { return success_events_; }
   ScopedVector<ErrorEvent>& error_events() { return error_events_; }
 
   base::WeakPtr<EventLogger> GetWeakPtr() {
@@ skipping 21 matching lines @@
   // RequestManager::Handler overrides.
   bool Execute(int request_id) override {
     if (logger_.get())
       logger_->OnExecute(request_id);
 
     return execute_reply_;
   }
 
   // RequestManager::Handler overrides.
   void OnSuccess(int request_id,
-                 scoped_ptr<RequestValue> result,
+                 std::unique_ptr<RequestValue> result,
                  bool has_more) override {
     if (logger_.get())
       logger_->OnSuccess(request_id, std::move(result), has_more);
   }
 
   // RequestManager::Handler overrides.
   void OnError(int request_id,
-               scoped_ptr<RequestValue> result,
+               std::unique_ptr<RequestValue> result,
                base::File::Error error) override {
     if (logger_.get())
       logger_->OnError(request_id, std::move(result), error);
   }
 
   ~FakeHandler() override {}
 
  private:
   base::WeakPtr<EventLogger> logger_;
   bool execute_reply_;
@@ skipping 113 matching lines @@
 
   void SetUp() override {
     profile_.reset(new TestingProfile);
     notification_manager_.reset(new FakeNotificationManager);
     request_manager_.reset(new RequestManager(profile_.get(),
                                               std::string() /* extension_id */,
                                               notification_manager_.get()));
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-  scoped_ptr<TestingProfile> profile_;
-  scoped_ptr<FakeNotificationManager> notification_manager_;
-  scoped_ptr<RequestManager> request_manager_;
+  std::unique_ptr<TestingProfile> profile_;
+  std::unique_ptr<FakeNotificationManager> notification_manager_;
+  std::unique_ptr<RequestManager> request_manager_;
 };
 
 TEST_F(FileSystemProviderRequestManagerTest, CreateFailure) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
       TESTING,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
+      base::WrapUnique<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), false /* execute_reply */)));
 
   EXPECT_EQ(0, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   EXPECT_EQ(1u, observer.created().size());
   EXPECT_EQ(TESTING, observer.created()[0].type());
   EXPECT_EQ(1u, observer.destroyed().size());
   EXPECT_EQ(0u, observer.executed().size());
 
   const std::vector<int> active_request_ids =
       request_manager_->GetActiveRequestIds();
   EXPECT_EQ(0u, active_request_ids.size());
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
       TESTING,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
+      base::WrapUnique<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
   EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   const std::vector<int> active_request_ids =
       request_manager_->GetActiveRequestIds();
   ASSERT_EQ(1u, active_request_ids.size());
   EXPECT_EQ(request_id, active_request_ids[0]);
 
-  scoped_ptr<RequestValue> response(
+  std::unique_ptr<RequestValue> response(
       RequestValue::CreateForTesting("i-like-vanilla"));
   const bool has_more = false;
 
   const base::File::Error result = request_manager_->FulfillRequest(
       request_id, std::move(response), has_more);
   EXPECT_EQ(base::File::FILE_OK, result);
 
   ASSERT_EQ(1u, observer.fulfilled().size());
   EXPECT_EQ(request_id, observer.fulfilled()[0].request_id());
   EXPECT_FALSE(observer.fulfilled()[0].has_more());
 
   // Validate if the callback has correct arguments.
   ASSERT_EQ(1u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
   EventLogger::SuccessEvent* event = logger.success_events()[0];
   ASSERT_TRUE(event->result());
   const std::string* response_test_string = event->result()->testing_params();
   ASSERT_TRUE(response_test_string);
   EXPECT_EQ("i-like-vanilla", *response_test_string);
   EXPECT_FALSE(event->has_more());
 
   // Confirm, that the request is removed. Basically, fulfilling again for the
   // same request, should fail.
   {
     const std::vector<int> active_request_ids =
         request_manager_->GetActiveRequestIds();
     EXPECT_EQ(0u, active_request_ids.size());
 
     const base::File::Error retry = request_manager_->FulfillRequest(
-        request_id, scoped_ptr<RequestValue>(new RequestValue), has_more);
+        request_id, std::unique_ptr<RequestValue>(new RequestValue), has_more);
     EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, retry);
     EXPECT_EQ(1u, observer.fulfilled().size());
   }
 
   // Rejecting should also fail.
   {
     const base::File::Error retry = request_manager_->RejectRequest(
-        request_id, scoped_ptr<RequestValue>(new RequestValue()),
+        request_id, std::unique_ptr<RequestValue>(new RequestValue()),
         base::File::FILE_ERROR_FAILED);
     EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, retry);
     EXPECT_EQ(0u, observer.rejected().size());
   }
 
   ASSERT_EQ(1u, observer.destroyed().size());
   EXPECT_EQ(request_id, observer.destroyed()[0].request_id());
   EXPECT_EQ(0u, observer.timeouted().size());
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
       TESTING,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
+      base::WrapUnique<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
   EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   const bool has_more = true;
 
   const base::File::Error result = request_manager_->FulfillRequest(
-      request_id, scoped_ptr<RequestValue>(new RequestValue), has_more);
+      request_id, std::unique_ptr<RequestValue>(new RequestValue), has_more);
   EXPECT_EQ(base::File::FILE_OK, result);
 
   // Validate if the callback has correct arguments.
   ASSERT_EQ(1u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
   EventLogger::SuccessEvent* event = logger.success_events()[0];
   EXPECT_TRUE(event->result());
   EXPECT_TRUE(event->has_more());
 
   ASSERT_EQ(1u, observer.fulfilled().size());
   EXPECT_EQ(request_id, observer.fulfilled()[0].request_id());
   EXPECT_TRUE(observer.fulfilled()[0].has_more());
 
   // Confirm, that the request is not removed (since it has has_more == true).
   // Basically, fulfilling again for the same request, should not fail.
   {
     const std::vector<int> active_request_ids =
         request_manager_->GetActiveRequestIds();
     ASSERT_EQ(1u, active_request_ids.size());
     EXPECT_EQ(request_id, active_request_ids[0]);
 
     const bool new_has_more = false;
     const base::File::Error retry = request_manager_->FulfillRequest(
-        request_id, scoped_ptr<RequestValue>(new RequestValue), new_has_more);
+        request_id, std::unique_ptr<RequestValue>(new RequestValue),
+        new_has_more);
     EXPECT_EQ(base::File::FILE_OK, retry);
 
     ASSERT_EQ(2u, observer.fulfilled().size());
     EXPECT_EQ(request_id, observer.fulfilled()[1].request_id());
     EXPECT_FALSE(observer.fulfilled()[1].has_more());
   }
 
   // Since |new_has_more| is false, then the request should be removed. To check
   // it, try to fulfill again, what should fail.
   {
     const std::vector<int> active_request_ids =
         request_manager_->GetActiveRequestIds();
     EXPECT_EQ(0u, active_request_ids.size());
 
     const bool new_has_more = false;
     const base::File::Error retry = request_manager_->FulfillRequest(
-        request_id, scoped_ptr<RequestValue>(new RequestValue), new_has_more);
+        request_id, std::unique_ptr<RequestValue>(new RequestValue),
+        new_has_more);
     EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, retry);
     EXPECT_EQ(0u, observer.rejected().size());
   }
 
   ASSERT_EQ(1u, observer.destroyed().size());
   EXPECT_EQ(request_id, observer.destroyed()[0].request_id());
   EXPECT_EQ(0u, observer.timeouted().size());
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
       TESTING,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
+      base::WrapUnique<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
   EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   const base::File::Error error = base::File::FILE_ERROR_NO_MEMORY;
   const base::File::Error result = request_manager_->RejectRequest(
-      request_id, scoped_ptr<RequestValue>(new RequestValue()), error);
+      request_id, std::unique_ptr<RequestValue>(new RequestValue()), error);
   EXPECT_EQ(base::File::FILE_OK, result);
 
   // Validate if the callback has correct arguments.
   ASSERT_EQ(1u, logger.error_events().size());
   EXPECT_EQ(0u, logger.success_events().size());
   EventLogger::ErrorEvent* event = logger.error_events()[0];
   EXPECT_EQ(error, event->error());
 
   ASSERT_EQ(1u, observer.rejected().size());
   EXPECT_EQ(request_id, observer.rejected()[0].request_id());
   EXPECT_EQ(error, observer.rejected()[0].error());
 
   // Confirm, that the request is removed. Basically, fulfilling again for the
   // same request, should fail.
   {
     const bool has_more = false;
     const base::File::Error retry = request_manager_->FulfillRequest(
-        request_id, scoped_ptr<RequestValue>(new RequestValue), has_more);
+        request_id, std::unique_ptr<RequestValue>(new RequestValue), has_more);
     EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, retry);
     EXPECT_EQ(0u, observer.fulfilled().size());
   }
 
   // Rejecting should also fail.
   {
     const base::File::Error retry = request_manager_->RejectRequest(
-        request_id, scoped_ptr<RequestValue>(new RequestValue()), error);
+        request_id, std::unique_ptr<RequestValue>(new RequestValue()), error);
     EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, retry);
     EXPECT_EQ(1u, observer.rejected().size());
   }
 
   ASSERT_EQ(1u, observer.destroyed().size());
   EXPECT_EQ(request_id, observer.destroyed()[0].request_id());
   EXPECT_EQ(0u, observer.timeouted().size());
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest,
        CreateAndFulfillWithWrongRequestId) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
       TESTING,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
+      base::WrapUnique<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
   EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   const bool has_more = true;
 
   const base::File::Error result = request_manager_->FulfillRequest(
-      request_id + 1, scoped_ptr<RequestValue>(new RequestValue), has_more);
+      request_id + 1, std::unique_ptr<RequestValue>(new RequestValue),
+      has_more);
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, result);
 
   // Callbacks should not be called.
   EXPECT_EQ(0u, logger.error_events().size());
   EXPECT_EQ(0u, logger.success_events().size());
 
   EXPECT_EQ(0u, observer.fulfilled().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   // Confirm, that the request hasn't been removed, by fulfilling it correctly.
   {
     const base::File::Error retry = request_manager_->FulfillRequest(
-        request_id, scoped_ptr<RequestValue>(new RequestValue), has_more);
+        request_id, std::unique_ptr<RequestValue>(new RequestValue), has_more);
     EXPECT_EQ(base::File::FILE_OK, retry);
     EXPECT_EQ(1u, observer.fulfilled().size());
   }
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest,
        CreateAndRejectWithWrongRequestId) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   const int request_id = request_manager_->CreateRequest(
       TESTING,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
+      base::WrapUnique<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
   EXPECT_EQ(TESTING, observer.created()[0].type());
 
   ASSERT_EQ(1u, observer.executed().size());
   EXPECT_EQ(request_id, observer.executed()[0].request_id());
 
   const base::File::Error error = base::File::FILE_ERROR_NO_MEMORY;
   const base::File::Error result = request_manager_->RejectRequest(
-      request_id + 1, scoped_ptr<RequestValue>(new RequestValue()), error);
+      request_id + 1, std::unique_ptr<RequestValue>(new RequestValue()), error);
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, result);
 
   // Callbacks should not be called.
   EXPECT_EQ(0u, logger.error_events().size());
   EXPECT_EQ(0u, logger.success_events().size());
 
   EXPECT_EQ(0u, observer.rejected().size());
 
   // Confirm, that the request hasn't been removed, by rejecting it correctly.
   {
     const base::File::Error retry = request_manager_->RejectRequest(
-        request_id, scoped_ptr<RequestValue>(new RequestValue()), error);
+        request_id, std::unique_ptr<RequestValue>(new RequestValue()), error);
     EXPECT_EQ(base::File::FILE_OK, retry);
     EXPECT_EQ(1u, observer.rejected().size());
   }
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) {
   EventLogger logger;
 
   const int first_request_id = request_manager_->CreateRequest(
       TESTING,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
+      base::WrapUnique<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   const int second_request_id = request_manager_->CreateRequest(
       TESTING,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
+      base::WrapUnique<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
   EXPECT_EQ(1, first_request_id);
   EXPECT_EQ(2, second_request_id);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, AbortOnDestroy) {
   EventLogger logger;
   RequestObserver observer;
   int request_id;
 
   {
     RequestManager request_manager(profile_.get(),
                                    std::string() /* extension_id */, nullptr);
     request_manager.AddObserver(&observer);
 
     request_id = request_manager.CreateRequest(
         TESTING,
-        make_scoped_ptr<RequestManager::HandlerInterface>(
+        base::WrapUnique<RequestManager::HandlerInterface>(
             new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
 
     EXPECT_EQ(1, request_id);
     EXPECT_EQ(0u, logger.success_events().size());
     EXPECT_EQ(0u, logger.error_events().size());
 
     ASSERT_EQ(1u, observer.created().size());
     EXPECT_EQ(request_id, observer.created()[0].request_id());
     EXPECT_EQ(TESTING, observer.created()[0].type());
 
@@ skipping 24 matching lines @@
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, AbortOnTimeout) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   request_manager_->SetTimeoutForTesting(base::TimeDelta::FromSeconds(0));
   const int request_id = request_manager_->CreateRequest(
       TESTING,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
+      base::WrapUnique<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
   EXPECT_EQ(0u, notification_manager_->size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
   EXPECT_EQ(TESTING, observer.created()[0].type());
 
@@ skipping 24 matching lines @@
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, ContinueOnTimeout) {
   EventLogger logger;
   RequestObserver observer;
   request_manager_->AddObserver(&observer);
 
   request_manager_->SetTimeoutForTesting(base::TimeDelta::FromSeconds(0));
   const int request_id = request_manager_->CreateRequest(
       TESTING,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
+      base::WrapUnique<RequestManager::HandlerInterface>(
           new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */)));
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(0u, logger.success_events().size());
   EXPECT_EQ(0u, logger.error_events().size());
   EXPECT_EQ(0u, notification_manager_->size());
 
   ASSERT_EQ(1u, observer.created().size());
   EXPECT_EQ(request_id, observer.created()[0].request_id());
   EXPECT_EQ(TESTING, observer.created()[0].type());
 
@@ skipping 14 matching lines @@
 
   // Wait until the request is timeouted again.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, notification_manager_->size());
 
   request_manager_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos