Add CompletionTask to PPAPI TrackedCallback.

ppapi/shared_impl/tracked_callback.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 "ppapi/shared_impl/tracked_callback.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_message_loop.h"
 #include "ppapi/shared_impl/callback_tracker.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppb_message_loop_shared.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource.h"
 
 namespace ppapi {
 
 namespace {
 
 bool IsMainThread() {
   return
       PpapiGlobals::Get()->GetMainThreadMessageLoop()->BelongsToCurrentThread();
 }
 
+int32_t RunCompletionTask(TrackedCallback::CompletionTask completion_task,
+                          int32_t result) {
+  int32_t task_result = completion_task.Run(result);
+  if (result != PP_ERROR_ABORTED)
+    result = task_result;
+  return result;
+}
+
 }  // namespace
 
 // TrackedCallback -------------------------------------------------------------
 
 // Note: don't keep a Resource* since it may go out of scope before us.
 TrackedCallback::TrackedCallback(
     Resource* resource,
     const PP_CompletionCallback& callback)
     : is_scheduled_(false),
       resource_id_(resource ? resource->pp_resource() : 0),
@@ skipping 81 matching lines @@
     // Wait()s.
     operation_completed_condvar_->Signal();
   } else {
     // If there's a target_loop_, and we're not on the right thread, we need to
     // post to target_loop_.
     if (target_loop_.get() &&
         target_loop_.get() != PpapiGlobals::Get()->GetCurrentMessageLoop()) {
       PostRun(result);
       return;
     }
-    // Copy |callback_| now, since |MarkAsCompleted()| may delete us.
+
+    // Copy callback fields now, since |MarkAsCompleted()| may delete us.
     PP_CompletionCallback callback = callback_;
-    // Do this before running the callback in case of reentrancy (which
-    // shouldn't happen, but avoid strange failures).
+    CompletionTask completion_task = completion_task_;
+    completion_task_.Reset();
+    // Do this before running the callback in case of reentrancy from running
+    // the completion task.
     MarkAsCompleted();
+
+    if (!completion_task.is_null())
+      result = RunCompletionTask(completion_task, result);
+
     // TODO(dmichael): Associate a message loop with the callback; if it's not
     // the same as the current thread's loop, then post it to the right loop.
     CallWhileUnlocked(PP_RunCompletionCallback, &callback, result);
   }
 }
 
 void TrackedCallback::PostRun(int32_t result) {
   if (completed()) {
     NOTREACHED();
     return;
@@ skipping 11 matching lines @@
     // classes protect against having a null target_loop_ otherwise).
     DCHECK(IsMainThread());
     DCHECK(PpapiGlobals::Get()->IsHostGlobals());
     base::MessageLoop::current()->PostTask(FROM_HERE, callback_closure);
   } else {
     target_loop_->PostClosure(FROM_HERE, callback_closure, 0);
   }
   is_scheduled_ = true;
 }
 
+void TrackedCallback::set_completion_task(
+    const CompletionTask& completion_task) {
+  DCHECK(completion_task_.is_null());
+  completion_task_ = completion_task;
+}
+
 // static
 bool TrackedCallback::IsPending(
     const scoped_refptr<TrackedCallback>& callback) {
   if (!callback.get())
     return false;
   if (callback->aborted())
     return false;
   return !callback->completed();
 }
 
@@ skipping 11 matching lines @@
   // BlockUntilComplete should never be called for in-process plugins, where
   // blocking callbacks are not supported.
   CHECK(operation_completed_condvar_.get());
   if (!is_blocking() || !operation_completed_condvar_.get()) {
     NOTREACHED();
     return PP_ERROR_FAILED;
   }
 
   while (!completed())
     operation_completed_condvar_->Wait();
+
+  if (!completion_task_.is_null()) {
+    result_for_blocked_callback_ =
+        RunCompletionTask(completion_task_, result_for_blocked_callback_);
+    completion_task_.Reset();
+  }
   return result_for_blocked_callback_;
 }
 
 void TrackedCallback::MarkAsCompleted() {
   DCHECK(!completed());
 
   // We will be removed; maintain a reference to ensure we won't be deleted
   // until we're done.
   scoped_refptr<TrackedCallback> thiz = this;
   completed_ = true;
   // We may not have a valid resource, in which case we're not in the tracker.
   if (resource_id_)
     tracker_->Remove(thiz);
   tracker_ = NULL;
 }
 
 }  // namespace ppapi