Remove unused Tuple dispatch functions

base/tuple.h

 // Copyright (c) 2011 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.
 
 // A Tuple is a generic templatized container, similar in concept to std::pair
 // and std::tuple.  The convenient MakeTuple() function takes any number of
 // arguments and will construct and return the appropriate Tuple object.  The
 // functions DispatchToMethod and DispatchToFunction take a function pointer or
 // instance and method pointer, and unpack a tuple into arguments to the call.
 //
@@ skipping 223 matching lines @@
 //
 // Helper functions that call the given method on an object, with the unpacked
 // tuple arguments.  Notice that they all have the same number of arguments,
 // so you need only write:
 //   DispatchToMethod(object, &Object::method, args);
 // This is very useful for templated dispatchers, since they don't need to know
 // what type |args| is.
 
 // Non-Static Dispatchers with no out params.
 
-template <typename ObjT, typename Method, typename A>
-inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
-}
-
 template <typename ObjT, typename Method, typename... Ts, size_t... Ns>
 inline void DispatchToMethodImpl(ObjT* obj,
                                  Method method,
                                  const Tuple<Ts...>& arg,
                                  IndexSequence<Ns...>) {
   (obj->*method)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
 }
 
 template <typename ObjT, typename Method, typename... Ts>
 inline void DispatchToMethod(ObjT* obj,
                              Method method,
                              const Tuple<Ts...>& arg) {
   DispatchToMethodImpl(obj, method, arg, MakeIndexSequence<sizeof...(Ts)>());
 }
 
 // Static Dispatchers with no out params.
 
-template <typename Function, typename A>
-inline void DispatchToMethod(Function function, const A& arg) {
-  (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg));
-}
-
 template <typename Function, typename... Ts, size_t... Ns>
 inline void DispatchToFunctionImpl(Function function,
                                    const Tuple<Ts...>& arg,
                                    IndexSequence<Ns...>) {
   (*function)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
 }
 
 template <typename Function, typename... Ts>
 inline void DispatchToFunction(Function function, const Tuple<Ts...>& arg) {
   DispatchToFunctionImpl(function, arg, MakeIndexSequence<sizeof...(Ts)>());
 }
 
 // Dispatchers with out parameters.
 
 template <typename ObjT,
           typename Method,
-          typename In,
-          typename... OutTs,
-          size_t... OutNs>
-inline void DispatchToMethodImpl(ObjT* obj,
-                                 Method method,
-                                 const In& in,
-                                 Tuple<OutTs...>* out,
-                                 IndexSequence<OutNs...>) {
-  (obj->*method)(base::internal::UnwrapTraits<In>::Unwrap(in),
-                 &get<OutNs>(*out)...);
-}
-
-template <typename ObjT, typename Method, typename In, typename... OutTs>
-inline void DispatchToMethod(ObjT* obj,
-                             Method method,
-                             const In& in,
-                             Tuple<OutTs...>* out) {
-  DispatchToMethodImpl(obj, method, in, out,
-                       MakeIndexSequence<sizeof...(OutTs)>());
-}
-
-template <typename ObjT,
-          typename Method,
           typename... InTs,
           typename... OutTs,
           size_t... InNs,
           size_t... OutNs>
 inline void DispatchToMethodImpl(ObjT* obj,
                                  Method method,
                                  const Tuple<InTs...>& in,
                                  Tuple<OutTs...>* out,
                                  IndexSequence<InNs...>,
                                  IndexSequence<OutNs...>) {
   (obj->*method)(base::internal::UnwrapTraits<InTs>::Unwrap(get<InNs>(in))...,
                  &get<OutNs>(*out)...);
 }
 
 template <typename ObjT, typename Method, typename... InTs, typename... OutTs>
 inline void DispatchToMethod(ObjT* obj,
                              Method method,
                              const Tuple<InTs...>& in,
                              Tuple<OutTs...>* out) {
   DispatchToMethodImpl(obj, method, in, out,
                        MakeIndexSequence<sizeof...(InTs)>(),
                        MakeIndexSequence<sizeof...(OutTs)>());
 }
 
 }  // namespace base
 
 #endif  // BASE_TUPLE_H_