Add CompletionTask to PPAPI TrackedCallback.

ppapi/shared_impl/tracked_callback.cc

Index: ppapi/shared_impl/tracked_callback.cc
diff --git a/ppapi/shared_impl/tracked_callback.cc b/ppapi/shared_impl/tracked_callback.cc
index 854e9dfb1509ebb843cdbc9633b1c6aca5371f5a..d98d56bf2138d9c5e6169c4a2577562acfbabfbf 100644
--- a/ppapi/shared_impl/tracked_callback.cc
+++ b/ppapi/shared_impl/tracked_callback.cc
@@ -128,11 +128,18 @@ void TrackedCallback::Run(int32_t result) {
       PostRun(result);
       return;
     }
-    // Copy |callback_| now, since |MarkAsCompleted()| may delete us.
+
+    // Copy callback fields now, since |MarkAsCompleted()| may delete us.
     PP_CompletionCallback callback = callback_;
+    CompletionTask completion_task = completion_task_;
+    completion_task_.Reset();
     // Do this before running the callback in case of reentrancy (which
     // shouldn't happen, but avoid strange failures).

[yzshen1, 2013/08/08 23:55:49]

nit: Please update the comment: With completion_task_ now reentrancy may happen
if we don't mark as completed. (so the part in the parentheses is not needed).

[bbudge, 2013/08/09 18:56:26]

Done.

     MarkAsCompleted();
+
+    if (!completion_task.is_null())
+      result = completion_task.Run(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);
@@ -164,6 +171,12 @@ void TrackedCallback::PostRun(int32_t result) {
   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) {
@@ -195,7 +208,13 @@ int32_t TrackedCallback::BlockUntilComplete() {
 
   while (!completed())
     operation_completed_condvar_->Wait();
-  return result_for_blocked_callback_;
+

[bbudge, 2013/08/08 18:34:00]

David, is it safe to access member fields here? Could the object have been
deleted where we Signal above?

[dmichael (off chromium), 2013/08/08 20:45:44]

Should be safe.

There are two things that could make it unsafe:
1) If we didn't have the lock. But we came back from the condvar Wait, so we're
good there.
2) If the TrackedCallback could have been deleted. But BlockUntilComplete is
only called from EnterBase::SetResult (we use friendship and keep
BlockUntilPrivate private to help enforce that). EnterBase keeps a
scoped_refptr<TrackedCallback> while it's on the stack. We should be good. But
if you want to be super careful, you could add a local:
 scoped_refptr<TrackedCallback> pin_in_memory(this);

+  int32_t result = result_for_blocked_callback_;
+  if (!completion_task_.is_null()) {
+    result = completion_task_.Run(result);
+    completion_task_.Reset();
+  }
+  return result;
 }
 
 void TrackedCallback::MarkAsCompleted() {