Update base::BindBlock for three parameters.

base/mac/bind_objc_block.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 BASE_MAC_BIND_OBJC_BLOCK_H_
 #define BASE_MAC_BIND_OBJC_BLOCK_H_
 
 #include <Block.h>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
   R(^extracted_block)(A1) = block.get();
   return extracted_block(a);
 }
 
 template<typename R, typename A1, typename A2>
 R RunBlock(base::mac::ScopedBlock<R(^)(A1, A2)> block, A1 a, A2 b) {
   R(^extracted_block)(A1, A2) = block.get();
   return extracted_block(a, b);
 }
 
+template<typename R, typename A1, typename A2, typename A3>
+R RunBlock(base::mac::ScopedBlock<R(^)(A1, A2, A3)> block, A1 a, A2 b, A3 c) {
+  R(^extracted_block)(A1, A2, A3) = block.get();
+  return extracted_block(a, b, c);

[Nico, 2014/11/06 17:44:47]

Can you make RunBlock() a variadic template? Then it'll work with all numbers of
parameters.

Something like:

template<typename R, typename... Args>
R RunBlock(base::mac::ScopedBlock<R(^)(Args...)> block, Args...) {
  return block.get()(Args..);
}

(untested, I probably screwed up the syntax somewhere.)

[marq (ping after 24h), 2014/11/07 09:00:55]

Done, and BindBlock() is now also variadic. 

+}
+
 }  // namespace internal
 
 // Construct a callback with no argument from an objective-C block.
 template<typename R>
 base::Callback<R(void)> BindBlock(R(^block)()) {
   return base::Bind(&base::internal::RunBlock<R>,
                     base::mac::ScopedBlock<R(^)()>(Block_copy(block)));
 }
 
 // Construct a callback with one argument from an objective-C block.
 template<typename R, typename A1>
 base::Callback<R(A1)> BindBlock(R(^block)(A1)) {
   return base::Bind(&base::internal::RunBlock<R, A1>,
                     base::mac::ScopedBlock<R(^)(A1)>(Block_copy(block)));
 }
 
 // Construct a callback with two arguments from an objective-C block.
 template<typename R, typename A1, typename A2>
 base::Callback<R(A1, A2)> BindBlock(R(^block)(A1, A2)) {
   return base::Bind(&base::internal::RunBlock<R, A1, A2>,
                     base::mac::ScopedBlock<R(^)(A1, A2)>(Block_copy(block)));
 }
 
+// Construct a callback with three arguments from an objective-C block.
+template<typename R, typename A1, typename A2, typename A3>
+base::Callback<R(A1, A2, A3)> BindBlock(R(^block)(A1, A2, A3)) {
+  return base::Bind(&base::internal::RunBlock<R, A1, A2, A3>,
+                    base::mac::ScopedBlock<R(^)(A1, A2, A3)>(
+                        Block_copy(block)));
+}
+
 }  // namespace base
 
 #endif  // BASE_MAC_BIND_OBJC_BLOCK_H_