Do PPB_FileIO Query and Read in the plugin process.

ppapi/shared_impl/tracked_callback_unittest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/callback_tracker.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/resource_tracker.h"
 #include "ppapi/shared_impl/test_globals.h"
 #include "ppapi/shared_impl/tracked_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 15 matching lines @@
   virtual void TearDown() OVERRIDE {
     globals_.GetResourceTracker()->DidDeleteInstance(pp_instance_);
   }
 
  private:
   base::MessageLoop message_loop_;
   TestGlobals globals_;
   PP_Instance pp_instance_;
 };
 
+// All valid results (PP_OK, PP_ERROR_...) are nonpositive.
+const int32_t kInitializedResultValue = 1;
+const int32_t kOverrideResultValue = 2;
+
 struct CallbackRunInfo {
-  // All valid results (PP_OK, PP_ERROR_...) are nonpositive.
-  CallbackRunInfo() : run_count(0), result(1) {}
+  CallbackRunInfo()
+      : run_count(0),
+        result(kInitializedResultValue),
+        completion_task_run_count(0),
+        completion_task_result(kInitializedResultValue) {}
   unsigned run_count;
   int32_t result;
+  unsigned completion_task_run_count;
+  int32_t completion_task_result;
 };
 
 void TestCallback(void* user_data, int32_t result) {
   CallbackRunInfo* info = reinterpret_cast<CallbackRunInfo*>(user_data);
   info->run_count++;
   if (info->run_count == 1)
     info->result = result;
 }
 
 }  // namespace
@@ skipping 82 matching lines @@
   ~CallbackMockResource() {}
 
   PP_Resource SetupForTest() {
     PP_Resource resource_id = GetReference();
     EXPECT_NE(0, resource_id);
 
     callback_did_run_ = new TrackedCallback(
         this,
         PP_MakeCompletionCallback(&TestCallback, &info_did_run_));
     EXPECT_EQ(0U, info_did_run_.run_count);
+    EXPECT_EQ(0U, info_did_run_.completion_task_run_count);
+
+    // In order to test that the completion task can override the callback
+    // result, we need to test callbacks with and without a completion task.
+    callback_did_run_with_completion_task_ = new TrackedCallback(
+        this,
+        PP_MakeCompletionCallback(&TestCallback,
+                                  &info_did_run_with_completion_task_));
+    callback_did_run_with_completion_task_->set_completion_task(
+        Bind(&CallbackMockResource::CompletionTask, this,
+             &info_did_run_with_completion_task_));
+    EXPECT_EQ(0U, info_did_run_with_completion_task_.run_count);
+    EXPECT_EQ(0U, info_did_run_with_completion_task_.completion_task_run_count);
 
     callback_did_abort_ = new TrackedCallback(
         this,
         PP_MakeCompletionCallback(&TestCallback, &info_did_abort_));
+    callback_did_abort_->set_completion_task(
+        Bind(&CallbackMockResource::CompletionTask, this, &info_did_abort_));
     EXPECT_EQ(0U, info_did_abort_.run_count);
+    EXPECT_EQ(0U, info_did_abort_.completion_task_run_count);
 
     callback_didnt_run_ = new TrackedCallback(
         this,
         PP_MakeCompletionCallback(&TestCallback, &info_didnt_run_));
+    callback_didnt_run_->set_completion_task(
+        Bind(&CallbackMockResource::CompletionTask, this, &info_didnt_run_));
     EXPECT_EQ(0U, info_didnt_run_.run_count);
+    EXPECT_EQ(0U, info_didnt_run_.completion_task_run_count);
 
     callback_did_run_->Run(PP_OK);
+    callback_did_run_with_completion_task_->Run(PP_OK);
     callback_did_abort_->Abort();
 
     CheckIntermediateState();
 
     return resource_id;
   }
 
+  int32_t CompletionTask(CallbackRunInfo* info, int32_t result) {
+    // We should run before the callback.
+    EXPECT_EQ(0U, info->run_count);
+    info->completion_task_run_count++;
+    if (info->completion_task_run_count == 1)
+      info->completion_task_result = result;
+    return kOverrideResultValue;
+  }
+
   void CheckIntermediateState() {
     EXPECT_EQ(1U, info_did_run_.run_count);
     EXPECT_EQ(PP_OK, info_did_run_.result);
+    EXPECT_EQ(0U, info_did_run_.completion_task_run_count);
+
+    EXPECT_EQ(1U, info_did_run_with_completion_task_.run_count);
+    // completion task should override the result.
+    EXPECT_EQ(kOverrideResultValue, info_did_run_with_completion_task_.result);
+    EXPECT_EQ(1U, info_did_run_with_completion_task_.completion_task_run_count);
+    EXPECT_EQ(PP_OK,
+              info_did_run_with_completion_task_.completion_task_result);
 
     EXPECT_EQ(1U, info_did_abort_.run_count);
+    // completion task shouldn't override an abort.
     EXPECT_EQ(PP_ERROR_ABORTED, info_did_abort_.result);
+    EXPECT_EQ(1U, info_did_abort_.completion_task_run_count);
+    EXPECT_EQ(PP_ERROR_ABORTED, info_did_abort_.completion_task_result);
 
+    EXPECT_EQ(0U, info_didnt_run_.completion_task_run_count);
     EXPECT_EQ(0U, info_didnt_run_.run_count);
   }
 
   void CheckFinalState() {
     EXPECT_EQ(1U, info_did_run_.run_count);
     EXPECT_EQ(PP_OK, info_did_run_.result);
     EXPECT_EQ(1U, info_did_abort_.run_count);
     EXPECT_EQ(PP_ERROR_ABORTED, info_did_abort_.result);
     EXPECT_EQ(1U, info_didnt_run_.run_count);
     EXPECT_EQ(PP_ERROR_ABORTED, info_didnt_run_.result);
   }
 
   scoped_refptr<TrackedCallback> callback_did_run_;
   CallbackRunInfo info_did_run_;
 
+  scoped_refptr<TrackedCallback> callback_did_run_with_completion_task_;
+  CallbackRunInfo info_did_run_with_completion_task_;
+
   scoped_refptr<TrackedCallback> callback_did_abort_;
   CallbackRunInfo info_did_abort_;
 
   scoped_refptr<TrackedCallback> callback_didnt_run_;
   CallbackRunInfo info_didnt_run_;
 };
 
 }  // namespace
 
 // Test that callbacks get aborted on the last resource unref.
@@ skipping 59 matching lines @@
   // Unref it again and do the same.
   resource_tracker->ReleaseResource(new_resource_id);
   base::MessageLoop::current()->RunUntilIdle();
   resource->CheckFinalState();
 
   // This shouldn't be needed, but make sure there are no stranded tasks.
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace ppapi