PPAPI: Make blocking completion callbacks work.

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"
@@ skipping 108 matching lines @@
 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);
 }
+void PPAPI_SHARED_EXPORT CallWhileUnlocked(const base::Closure& closure);
 
 // 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 PPAPI_SHARED_EXPORT 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_