Decouple Media Service

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 210 matching lines @@
 
 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 P,
+          typename... InTs,
+          typename... OutTs,
+          size_t... InNs,
+          size_t... OutNs>
+inline void DispatchToMethodImpl(const ObjT& obj,
+                                 Method method,
+                                 P* parameter,
+                                 const Tuple<InTs...>& in,
+                                 Tuple<OutTs...>* out,
+                                 IndexSequence<InNs...>,
+                                 IndexSequence<OutNs...>) {
+  (obj->*method)(parameter, internal::Unwrap(get<InNs>(in))...,
+                 &get<OutNs>(*out)...);
+}
+
+template <typename ObjT,
+          typename P,
+          typename... Args,
+          typename... InTs,
+          typename... OutTs,
+          typename std::enable_if<!std::is_void<P>::value>::type* = nullptr>

[danakj, 2016/03/03 21:00:28]

I know you're working around msvc bugs but I don't agree with this being in the
base library, it has some pretty strange behavior wrt void*.

I'd also like to not make these Dispatch things more complicated, and prefer you
to just do something one-off and preferably not templated where you want to use
this if possible.

+void DispatchToMethod(ObjT* obj,
+                      void (ObjT::*method)(P*, Args...),
+                      P* parameter,
+                      const base::Tuple<InTs...>& tuple,
+                      base::Tuple<OutTs...>* out) {
+  DispatchToMethodImpl(obj, method, parameter, tuple, out,
+                       MakeIndexSequence<sizeof...(InTs)>(),
+                       MakeIndexSequence<sizeof...(OutTs)>());
+}
+
+template <typename ObjT,
+          typename Method,
           typename... InTs,
           typename... OutTs,
           size_t... InNs,
           size_t... OutNs>
 inline void DispatchToMethodImpl(const ObjT& obj,
                                  Method method,
                                  const Tuple<InTs...>& in,
                                  Tuple<OutTs...>* out,
                                  IndexSequence<InNs...>,
                                  IndexSequence<OutNs...>) {
   (obj->*method)(internal::Unwrap(get<InNs>(in))..., &get<OutNs>(*out)...);
 }
 
-template <typename ObjT, typename Method, typename... InTs, typename... OutTs>
+template <typename ObjT,
+          typename Method,
+          typename P,
+          typename... InTs,
+          typename... OutTs>
 inline void DispatchToMethod(const ObjT& obj,
                              Method method,
+                             P* parameter,
                              const Tuple<InTs...>& in,
                              Tuple<OutTs...>* out) {
   DispatchToMethodImpl(obj, method, in, out,
                        MakeIndexSequence<sizeof...(InTs)>(),
                        MakeIndexSequence<sizeof...(OutTs)>());
 }
 
 }  // namespace base
 
 #endif  // BASE_TUPLE_H_