PPAPI: Make CallWhileUnlocked more permissive.

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 99 matching lines @@
 //
 // 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) {
+// Note we use 2 types for the params, even though for the most part we expect
+// A1 to match P1. We let the compiler determine if P1 can convert safely to
+// A1. This allows callers to avoid having to do things like
+// const_cast to add const.
+template <class ReturnType, class A1, class P1>
+ReturnType CallWhileUnlocked(ReturnType (*function)(A1), const P1& p1) {
   ProxyAutoUnlock unlock;
   return function(p1);
 }
-template <class ReturnType, class P1, class P2>
-ReturnType CallWhileUnlocked(ReturnType (*function)(P1, P2),
+template <class ReturnType, class A1, class A2, class P1, class P2>
+ReturnType CallWhileUnlocked(ReturnType (*function)(A1, A2),
                              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),
+template <class ReturnType, class A1, class A2, class A3, class P1, class P2,
+          class P3>
+ReturnType CallWhileUnlocked(ReturnType (*function)(A1, A2, A3),
                              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),
+template <class ReturnType, class A1, class A2, class A3, class A4, class P1,
+          class P2, class P3, class P4>
+ReturnType CallWhileUnlocked(ReturnType (*function)(A1, A2, A3, A4),
                              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),
+template <class ReturnType, class A1, class A2, class A3, class A4, class A5,
+          class P1, class P2, class P3, class P4, class P5>
+ReturnType CallWhileUnlocked(ReturnType (*function)(A1, A2, A3, A4, A5),
                              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);
 
@@ skipping 191 matching lines @@
   internal::RunWhileLockedHelper<FunctionType>* helper =
       new internal::RunWhileLockedHelper<FunctionType>(callback);
   return base::Bind(
       &internal::RunWhileLockedHelper<FunctionType>::CallWhileLocked,
       base::Owned(helper));
 }
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_PROXY_LOCK_H_