PPAPI: Make CompletionCallbacks work right on background threads.

ppapi/shared_impl/tracked_callback.h

 // 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.
 
 #ifndef PPAPI_SHARED_IMPL_TRACKED_CALLBACK_H_
 #define PPAPI_SHARED_IMPL_TRACKED_CALLBACK_H_
 
 #include <map>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/condition_variable.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/shared_impl/ppapi_shared_export.h"
+#include "ppapi/shared_impl/ppb_message_loop_shared.h"
 
 namespace ppapi {
 
 class CallbackTracker;
+class MessageLoopShared;
 class Resource;
 
 namespace thunk {
 namespace subtle {
 // For a friend declaration below.
 class EnterBase;
 }
 }
 
 // |TrackedCallback| represents a tracked Pepper callback (from the browser to
@@ skipping 36 matching lines @@
   void Abort();
   void PostAbort();
 
   // Run the callback with the given result. If the callback had previously been
   // marked as to be aborted (by |PostAbort()|), |result| will be ignored and
   // the callback will be run with result |PP_ERROR_ABORTED|.
   //
   // Run() will invoke the call immediately, if invoked from the target thread
   // (as determined by target_loop_). If invoked on a different thread, the
   // callback will be scheduled to run later on target_loop_.
-  // TODO(dmichael): Make the above part about different threads actually true.
   void Run(int32_t result);
   // PostRun is like Run(), except it guarantees that the callback will be run
   // later. In particular, if you invoke PostRun on the same thread on which the
   // callback is targeted to run, it will *not* be run immediately.
   void PostRun(int32_t result);
 
   void BlockUntilRun();
 
   // Returns the ID of the resource which "owns" the callback, or 0 if the
   // callback is not associated with any resource.
@@ skipping 19 matching lines @@
     return !callback_.func;
   }
   bool is_required() {
     return (callback_.func &&
             !(callback_.flags & PP_COMPLETIONCALLBACK_FLAG_OPTIONAL));
   }
   bool is_optional() {
     return (callback_.func &&
             (callback_.flags & PP_COMPLETIONCALLBACK_FLAG_OPTIONAL));
   }
+  bool has_null_target_loop() const {
+    return target_loop_ == NULL;
+  }
 
  private:
   // TrackedCallback and EnterBase manage dealing with how to invoke callbacks
   // appropriately. Pepper interface implementations and proxies should not have
   // to check the type of callback, block, or mark them complete explicitly.
   friend class ppapi::thunk::subtle::EnterBase;
 
   // Block until the associated operation has completed. Returns the result.
   // This must only be called on a non-main thread on a blocking callback.
   int32_t BlockUntilComplete();
@@ skipping 10 matching lines @@
   // Flag used by |PostAbort()| and |PostRun()| to check that we don't schedule
   // the callback more than once.
   bool is_scheduled_;
 
   scoped_refptr<CallbackTracker> tracker_;
   PP_Resource resource_id_;
   bool completed_;
   bool aborted_;
   PP_CompletionCallback callback_;
 
+  // The MessageLoopShared on which this callback should be run. This will be
+  // NULL if we're in-process.
+  scoped_refptr<MessageLoopShared> target_loop_;
+
   int32_t result_for_blocked_callback_;
   // Used for pausing/waking the blocked thread if this is a blocking completion
   // callback. Note that in-process, there is no lock, blocking callbacks are
   // not allowed, and therefore this pointer will be NULL.
   scoped_ptr<base::ConditionVariable> operation_completed_condvar_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TrackedCallback);
 };
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_TRACKED_CALLBACK_H_