[fsp] Add support for aborting running operations.

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 <map>
 #include <string>
 #include <vector>
 
@@ skipping 322 matching lines @@
 
   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>(
           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(
       RequestValue::CreateForTesting("i-like-vanilla"));
   const bool has_more = false;
 
   bool result =
       request_manager_->FulfillRequest(request_id, response.Pass(), has_more);
   EXPECT_TRUE(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());
+
     bool retry = request_manager_->FulfillRequest(
         request_id, scoped_ptr<RequestValue>(new RequestValue), has_more);
     EXPECT_FALSE(retry);
     EXPECT_EQ(1u, observer.fulfilled().size());
   }
 
   // Rejecting should also fail.
   {
     bool retry = request_manager_->RejectRequest(
         request_id,
@@ skipping 44 matching lines @@
   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]);
+
     bool new_has_more = false;
     bool retry = request_manager_->FulfillRequest(
         request_id, scoped_ptr<RequestValue>(new RequestValue), new_has_more);
     EXPECT_TRUE(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());
+
     bool new_has_more = false;
     bool retry = request_manager_->FulfillRequest(
         request_id, scoped_ptr<RequestValue>(new RequestValue), new_has_more);
     EXPECT_FALSE(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());
@@ skipping 298 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