[fsp] Cleanup handling errors for operation requests.

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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file.h"
@@ skipping 38 matching lines @@
     bool has_more() { return has_more_; }
 
    private:
     int request_id_;
     scoped_ptr<RequestValue> result_;
     bool has_more_;
   };
 
   class ErrorEvent {
    public:
-    ErrorEvent(int request_id, base::File::Error error)
-        : request_id_(request_id), error_(error) {}
+    ErrorEvent(int request_id,
+               scoped_ptr<RequestValue> result,
+               base::File::Error error)
+        : request_id_(request_id), result_(result.Pass()), 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_;
     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,
                  bool has_more) {
     success_events_.push_back(
         new SuccessEvent(request_id, result.Pass(), has_more));
   }
 
-  void OnError(int request_id, base::File::Error error) {
-    error_events_.push_back(new ErrorEvent(request_id, error));
+  void OnError(int request_id,
+               scoped_ptr<RequestValue> result,
+               base::File::Error error) {
+    error_events_.push_back(new ErrorEvent(request_id, result.Pass(), 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() {
     return weak_ptr_factory_.GetWeakPtr();
   }
 
@@ skipping 25 matching lines @@
 
   // RequestManager::Handler overrides.
   virtual void OnSuccess(int request_id,
                          scoped_ptr<RequestValue> result,
                          bool has_more) OVERRIDE {
     if (logger_.get())
       logger_->OnSuccess(request_id, result.Pass(), has_more);
   }
 
   // RequestManager::Handler overrides.
-  virtual void OnError(int request_id, base::File::Error error) OVERRIDE {
+  virtual void OnError(int request_id,
+                       scoped_ptr<RequestValue> result,
+                       base::File::Error error) OVERRIDE {
     if (logger_.get())
-      logger_->OnError(request_id, error);
+      logger_->OnError(request_id, result.Pass(), error);
   }
 
   virtual ~FakeHandler() {}
 
  private:
   base::WeakPtr<EventLogger> logger_;
   bool execute_reply_;
   DISALLOW_COPY_AND_ASSIGN(FakeHandler);
 };
 
@@ skipping 183 matching lines @@
   {
     scoped_ptr<RequestValue> response;
     bool retry =
         request_manager_->FulfillRequest(request_id, response.Pass(), has_more);
     EXPECT_FALSE(retry);
     EXPECT_EQ(1u, observer.fulfilled().size());
   }
 
   // Rejecting should also fail.
   {
-    bool retry = request_manager_->RejectRequest(request_id,
-                                                 base::File::FILE_ERROR_FAILED);
+    bool retry = request_manager_->RejectRequest(
+        request_id,
+        scoped_ptr<RequestValue>(new RequestValue()),
+        base::File::FILE_ERROR_FAILED);
     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());
 
   request_manager_->RemoveObserver(&observer);
 }
@@ skipping 82 matching lines @@
   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());
 
   base::File::Error error = base::File::FILE_ERROR_NO_MEMORY;
-  bool result = request_manager_->RejectRequest(request_id, error);
+  bool result = request_manager_->RejectRequest(
+      request_id, scoped_ptr<RequestValue>(new RequestValue()), error);
   EXPECT_TRUE(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.
   {
     scoped_ptr<RequestValue> response;
     bool has_more = false;
     bool retry =
         request_manager_->FulfillRequest(request_id, response.Pass(), has_more);
     EXPECT_FALSE(retry);
     EXPECT_EQ(0u, observer.fulfilled().size());
   }
 
   // Rejecting should also fail.
   {
-    bool retry = request_manager_->RejectRequest(request_id, error);
+    bool retry = request_manager_->RejectRequest(
+        request_id, scoped_ptr<RequestValue>(new RequestValue()), error);
     EXPECT_FALSE(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);
 }
@@ skipping 61 matching lines @@
   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());
 
   base::File::Error error = base::File::FILE_ERROR_NO_MEMORY;
-  bool result = request_manager_->RejectRequest(request_id + 1, error);
+  bool result = request_manager_->RejectRequest(
+      request_id + 1, scoped_ptr<RequestValue>(new RequestValue()), error);
   EXPECT_FALSE(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.
   {
-    bool retry = request_manager_->RejectRequest(request_id, error);
+    bool retry = request_manager_->RejectRequest(
+        request_id, scoped_ptr<RequestValue>(new RequestValue()), error);
     EXPECT_TRUE(retry);
     EXPECT_EQ(1u, observer.rejected().size());
   }
 
   request_manager_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) {
   EventLogger logger;
 
@@ skipping 93 matching lines @@
   ASSERT_EQ(1u, observer.timeouted().size());
   EXPECT_EQ(request_id, observer.timeouted()[0].request_id());
   ASSERT_EQ(1u, observer.destroyed().size());
   EXPECT_EQ(request_id, observer.destroyed()[0].request_id());
 
   request_manager_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos