ppapi/shared_impl/thread_aware_callback.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef PPAPI_SHARED_IMPL_THREAD_AWARE_CALLBACK_H_
   6 #define PPAPI_SHARED_IMPL_THREAD_AWARE_CALLBACK_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/bind.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "ppapi/shared_impl/ppapi_shared_export.h"
  12 #include "ppapi/shared_impl/proxy_lock.h"
  13
  14 namespace ppapi {
  15
  16 class MessageLoopShared;
  17
  18 namespace internal {
  19
  20 class PPAPI_SHARED_EXPORT ThreadAwareCallbackBase {
  21  protected:
  22   ThreadAwareCallbackBase();
  23   ~ThreadAwareCallbackBase();
  24
  25   static bool HasTargetLoop();
  26
  27   void InternalRunOnTargetThread(const base::Closure& closure);
  28
  29  private:
  30   class Core;
  31
  32   scoped_refptr<MessageLoopShared> target_loop_;
  33   scoped_refptr<Core> core_;
  34
  35   DISALLOW_COPY_AND_ASSIGN(ThreadAwareCallbackBase);
  36 };
  37
  38 }  // namespace internal
  39
  40 // Some PPB interfaces have methods that set a custom callback. Usually, the
  41 // callback has to be called on the same thread as the one it was set on.
  42 // ThreadAwareCallback keeps track of the target thread, and posts a task to run
  43 // on it if requested from a different thread.
  44 //
  45 // Please note that:
  46 // - Unlike TrackedCallback, there is no restriction on how many times the
  47 //   callback will be called.
  48 // - When a ThreadAwareCallback object is destroyed, all pending tasks to run
  49 //   the callback will be ignored. It is designed this way so that when the
  50 //   resource is destroyed or the callback is cancelled by the plugin, we can
  51 //   simply delete the ThreadAwareCallback object to prevent touching the
  52 //   callback later.
  53 // - When RunOnTargetThread() is called on the target thread, the callback runs
  54 //   immediately.
  55 template <class FuncType>
  56 class ThreadAwareCallback : public internal::ThreadAwareCallbackBase {
  57  public:
  58   // The caller takes ownership of the returned object.
  59   // NULL is returned if the current thread doesn't have an associated Pepper
  60   // message loop, or |func| is NULL.
  61   static ThreadAwareCallback* Create(FuncType func) {
  62     if (!func || !HasTargetLoop())
  63       return NULL;
  64     return new ThreadAwareCallback(func);
  65   }
  66
  67   ~ThreadAwareCallback() {
  68   }
  69
  70   void RunOnTargetThread() {
  71     InternalRunOnTargetThread(base::Bind(func_));
  72   }
  73
  74   template <class P1>
  75   void RunOnTargetThread(const P1& p1) {
  76     InternalRunOnTargetThread(base::Bind(func_, p1));
  77   }
  78
  79   template <class P1, class P2>
  80   void RunOnTargetThread(const P1& p1, const P2& p2) {
  81     InternalRunOnTargetThread(base::Bind(func_, p1, p2));
  82   }
  83
  84   template <class P1, class P2, class P3>
  85   void RunOnTargetThread(const P1& p1, const P2& p2, const P3& p3) {
  86     InternalRunOnTargetThread(base::Bind(func_, p1, p2, p3));
  87   }
  88
  89   template <class P1, class P2, class P3, class P4>
  90   void RunOnTargetThread(const P1& p1,
  91                          const P2& p2,
  92                          const P3& p3,
  93                          const P4& p4) {
  94     InternalRunOnTargetThread(base::Bind(func_, p1, p2, p3, p4));
  95   }
  96
  97   template <class P1, class P2, class P3, class P4, class P5>
  98   void RunOnTargetThread(const P1& p1,
  99                          const P2& p2,
 100                          const P3& p3,
 101                          const P4& p4,
 102                          const P5& p5) {
 103     InternalRunOnTargetThread(base::Bind(func_, p1, p2, p3, p4, p5));
 104   }
 105
 106  private:
 107   explicit ThreadAwareCallback(FuncType func) : func_(func) {
 108   }
 109
 110   FuncType func_;
 111 };
 112
 113 }  // namespace ppapi
 114
 115 #endif  // PPAPI_SHARED_IMPL_THREAD_AWARE_CALLBACK_H_