tuple: leave fields uninitialized in default constructors

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 97 matching lines @@
 
 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 {
-  TupleLeaf() : x() {}
+  TupleLeaf() {}
   explicit TupleLeaf(typename TupleTraits<T>::ParamType x) : x(x) {}
 
   T& get() { return x; }
   const T& get() const { return x; }
 
   T x;
 };
 
 // For legacy compatibility, we name the first 8 tuple elements "a", "b", ...
 // TODO(mdempsky): Update users to use get<N>() (crbug.com/440675).
 
 #define DEFINE_TUPLE_LEAF(N, x)                                        \
   template <typename T>                                                \
   struct TupleLeaf<N, T> {                                             \
-    TupleLeaf() : x() {}                                               \
+    TupleLeaf() {}                                                     \
     explicit TupleLeaf(typename TupleTraits<T>::ParamType x) : x(x) {} \
                                                                        \
     T& get() { return x; }                                             \
     const T& get() const { return x; }                                 \
                                                                        \
     T x;                                                               \
   }
 
 DEFINE_TUPLE_LEAF(0, a);
 DEFINE_TUPLE_LEAF(1, b);
@@ skipping 192 matching lines @@
 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)>());
 }
 
 #endif  // BASE_TUPLE_H__