Move Tuple to base namespace.

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 12 matching lines @@
 //
 //   struct { void SomeMeth(int a, int b, int c) { } } foo;
 //   DispatchToMethod(&foo, &Foo::SomeMeth, MakeTuple(1, 2, 3));
 //   // foo->SomeMeth(1, 2, 3);
 
 #ifndef BASE_TUPLE_H_
 #define BASE_TUPLE_H_
 
 #include "base/bind_helpers.h"
 
+namespace base {
+
 // Index sequences
 //
 // Minimal clone of the similarly-named C++14 functionality.
 
 template <size_t...>
 struct IndexSequence {};
 
 template <size_t... Ns>
 struct MakeIndexSequenceImpl;
 
@@ skipping 131 matching lines @@
   const T& get() const { return x; }
 
   T x;
 };
 
 // Tuple getters --------------------------------------------------------------
 //
 // Allows accessing an arbitrary tuple element by index.
 //
 // Example usage:
-//   Tuple<int, double> t2;
-//   get<0>(t2) = 42;
-//   get<1>(t2) = 3.14;
+//   base::Tuple<int, double> t2;
+//   base::get<0>(t2) = 42;
+//   base::get<1>(t2) = 3.14;
 
 template <size_t I, typename T>
 T& get(TupleLeaf<I, T>& leaf) {
   return leaf.get();
 }
 
 template <size_t I, typename T>
 const T& get(const TupleLeaf<I, T>& leaf) {
   return leaf.get();
 }
@@ skipping 125 matching lines @@
 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_