Mark base::Tuple as final

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 132 matching lines @@
 // output (a "tier").  See MakeRefTuple and its usages.
 
 template <typename IxSeq, typename... Ts>
 struct TupleBaseImpl;
 template <typename... Ts>
 using TupleBase = TupleBaseImpl<MakeIndexSequence<sizeof...(Ts)>, Ts...>;
 template <size_t N, typename T>
 struct TupleLeaf;
 
 template <typename... Ts>
-struct Tuple : TupleBase<Ts...> {
+struct Tuple final : TupleBase<Ts...> {
   Tuple() : TupleBase<Ts...>() {}
   explicit Tuple(typename TupleTraits<Ts>::ParamType... args)
       : TupleBase<Ts...>(args...) {}
 };
 
 // Avoids ambiguity between Tuple's two constructors.
 template <>
-struct Tuple<> {};
+struct Tuple<> final {};
 
 template <size_t... Ns, typename... Ts>
 struct TupleBaseImpl<IndexSequence<Ns...>, Ts...> : TupleLeaf<Ns, Ts>... {
   TupleBaseImpl() : TupleLeaf<Ns, Ts>()... {}
   explicit TupleBaseImpl(typename TupleTraits<Ts>::ParamType... args)
       : TupleLeaf<Ns, Ts>(args)... {}
 };
 
 template <size_t N, typename T>
 struct TupleLeaf {
@@ skipping 155 matching lines @@
                              const Tuple<InTs...>& in,
                              Tuple<OutTs...>* out) {
   DispatchToMethodImpl(obj, method, in, out,
                        MakeIndexSequence<sizeof...(InTs)>(),
                        MakeIndexSequence<sizeof...(OutTs)>());
 }
 
 }  // namespace base
 
 #endif  // BASE_TUPLE_H_