PPAPI: Add unlocking for PPP calls and callbacks. Add more locking.

ppapi/shared_impl/proxy_lock.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_PROXY_LOCK_H_
 #define PPAPI_SHARED_IMPL_PROXY_LOCK_H_
 
 #include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/callback.h"
 
 #include "ppapi/shared_impl/ppapi_shared_export.h"
 
 namespace base {
 class Lock;
 }
 
 namespace ppapi {
 
 // This is the one lock to rule them all for the ppapi proxy. All PPB interface
 // functions that need to be synchronized should lock this lock on entry. This
 // is normally accomplished by using an appropriate Enter RAII object at the
 // beginning of each thunk function.
 //
 // TODO(dmichael): If this turns out to be too slow and contentious, we'll want
 // to use multiple locks. E.g., one for the var tracker, one for the resource
 // tracker, etc.
 class PPAPI_SHARED_EXPORT ProxyLock {
  public:
   // Acquire the proxy lock. If it is currently held by another thread, block
   // until it is available. If the lock has not been set using the 'Set' method,
   // this operation does nothing. That is the normal case for the host side;
   // see PluginResourceTracker for where the lock gets set for the out-of-
   // process plugin case.
   static void Acquire();
   // Relinquish the proxy lock. If the lock has not been set, this does nothing.
   static void Release();
 
+ private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ProxyLock);
 };
 
 // A simple RAII class for locking the PPAPI proxy lock on entry and releasing
 // on exit. This is for simple interfaces that don't use the 'thunk' system,
 // such as PPB_Var and PPB_Core.
 class ProxyAutoLock {
  public:
   ProxyAutoLock() {
     ProxyLock::Acquire();
@@ skipping 14 matching lines @@
   ProxyAutoUnlock() {
     ProxyLock::Release();
   }
   ~ProxyAutoUnlock() {
     ProxyLock::Acquire();
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(ProxyAutoUnlock);
 };
 
+// A set of function template overloads for invoking a function pointer while
+// the ProxyLock is unlocked. This assumes that the luck is held.
+// CallWhileUnlocked unlocks the ProxyLock just before invoking the given
+// function. The lock is immediately re-acquired when the invoked function
+// function returns. CallWhileUnlocked returns whatever the given function
+// returned.
+//
+// Example usage:
+//   *result = CallWhileUnlocked(ppp_input_event_impl_->HandleInputEvent,
+//                               instance,
+//                               resource->pp_resource());
+template <class ReturnType>
+ReturnType CallWhileUnlocked(ReturnType (*function)()) {
+  ProxyAutoUnlock unlock;
+  return function();
+}
+template <class ReturnType, class P1>
+ReturnType CallWhileUnlocked(ReturnType (*function)(P1), const P1& p1) {
+  ProxyAutoUnlock unlock;
+  return function(p1);
+}
+template <class ReturnType, class P1, class P2>
+ReturnType CallWhileUnlocked(ReturnType (*function)(P1, P2),
+                             const P1& p1,
+                             const P2& p2) {
+  ProxyAutoUnlock unlock;
+  return function(p1, p2);
+}
+template <class ReturnType, class P1, class P2, class P3>
+ReturnType CallWhileUnlocked(ReturnType (*function)(P1, P2, P3),
+                             const P1& p1,
+                             const P2& p2,
+                             const P3& p3) {
+  ProxyAutoUnlock unlock;
+  return function(p1, p2, p3);
+}
+template <class ReturnType, class P1, class P2, class P3, class P4>
+ReturnType CallWhileUnlocked(ReturnType (*function)(P1, P2, P3, P4),
+                             const P1& p1,
+                             const P2& p2,
+                             const P3& p3,
+                             const P4& p4) {
+  ProxyAutoUnlock unlock;
+  return function(p1, p2, p3, p4);
+}
+template <class ReturnType, class P1, class P2, class P3, class P4, class P5>
+ReturnType CallWhileUnlocked(ReturnType (*function)(P1, P2, P3, P4, P5),
+                             const P1& p1,
+                             const P2& p2,
+                             const P3& p3,
+                             const P4& p4,
+                             const P5& p5) {
+  ProxyAutoUnlock unlock;
+  return function(p1, p2, p3, p4, p5);
+}
+
+// CallWhileLocked locks the ProxyLock and runs the given closure immediately.
+// The lock is released when CallWhileLocked returns. This function assumes the
+// lock is not held. This is mostly for use in RunWhileLocked; see below.
+void CallWhileLocked(const base::Closure& closure);
+
+// RunWhileLocked binds the given closure with CallWhileLocked and returns the
+// new Closure. This is for cases where you want to run a task, but you want to
+// ensure that the ProxyLock is acquired for the duration of the task.
+// Example usage:
+//   GetMainThreadMessageLoop()->PostDelayedTask(
+//     FROM_HERE,
+//     RunWhileLocked(base::Bind(&CallbackWrapper, callback, result)),
+//     delay_in_ms);
+inline base::Closure RunWhileLocked(const base::Closure& closure) {
+  return base::Bind(CallWhileLocked, closure);
+}
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_PROXY_LOCK_H_