Fix base::Optional constexpr ctor on gcc 4.8.

base/optional.h

 // Copyright 2016 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.
 
 #ifndef BASE_OPTIONAL_H_
 #define BASE_OPTIONAL_H_
 
 #include <type_traits>
 
 #include "base/logging.h"
@@ skipping 16 matching lines @@
 constexpr in_place_t in_place = {};
 
 // Specification:
 // http://en.cppreference.com/w/cpp/utility/optional/nullopt
 constexpr nullopt_t nullopt(0);
 
 namespace internal {
 
 template <typename T, bool = base::is_trivially_destructible<T>::value>
 struct OptionalStorage {
-  constexpr OptionalStorage() {}
+  // Initializing |empty_| here instead of using default member initializing
+  // to avoid errors in g++ 4.8.
+  constexpr OptionalStorage() : empty_('\0') {}
 
   constexpr explicit OptionalStorage(const T& value)
       : is_null_(false), value_(value) {}
 
   // TODO(alshabalin): Can't use 'constexpr' with std::move until C++14.
   explicit OptionalStorage(T&& value)
       : is_null_(false), value_(std::move(value)) {}
 
   // TODO(alshabalin): Can't use 'constexpr' with std::forward until C++14.
   template <class... Args>
   explicit OptionalStorage(base::in_place_t, Args&&... args)
       : is_null_(false), value_(std::forward<Args>(args)...) {}
 
   // When T is not trivially destructible we must call its
   // destructor before deallocating its memory.
   ~OptionalStorage() {
     if (!is_null_)
       value_.~T();
   }
 
   bool is_null_ = true;
   union {
     // |empty_| exists so that the union will always be initialized, even when
-    // it doesn't contain a value. Not initializing it has been observed to
-    // trigger comiler warnings.
-    char empty_ = '\0';
+    // it doesn't contain a value. Union members must be initialized for the
+    // constructor to be 'constexpr'.
+    char empty_;
     T value_;
   };
 };
 
 template <typename T>
 struct OptionalStorage<T, true> {
-  constexpr OptionalStorage() {}
+  // Initializing |empty_| here instead of using default member initializing
+  // to avoid errors in g++ 4.8.
+  constexpr OptionalStorage() : empty_('\0') {}
 
   constexpr explicit OptionalStorage(const T& value)
       : is_null_(false), value_(value) {}
 
   // TODO(alshabalin): Can't use 'constexpr' with std::move until C++14.
   explicit OptionalStorage(T&& value)
       : is_null_(false), value_(std::move(value)) {}
 
   // TODO(alshabalin): Can't use 'constexpr' with std::forward until C++14.
   template <class... Args>
   explicit OptionalStorage(base::in_place_t, Args&&... args)
       : is_null_(false), value_(std::forward<Args>(args)...) {}
 
   // When T is trivially destructible (i.e. its destructor does nothing) there
   // is no need to call it. Explicitly defaulting the destructor means it's not
   // user-provided. Those two together make this destructor trivial.
   ~OptionalStorage() = default;
 
   bool is_null_ = true;
   union {
     // |empty_| exists so that the union will always be initialized, even when
-    // it doesn't contain a value. Not initializing it has been observed to
-    // trigger comiler warnings.
-    char empty_ = '\0';
+    // it doesn't contain a value. Union members must be initialized for the
+    // constructor to be 'constexpr'.
+    char empty_;
     T value_;
   };
 };
 
 }  // namespace internal
 
 // base::Optional is a Chromium version of the C++17 optional class:
 // std::optional documentation:
 // http://en.cppreference.com/w/cpp/utility/optional
 // Chromium documentation:
@@ skipping 388 matching lines @@
 template <class T>
 struct hash<base::Optional<T>> {
   size_t operator()(const base::Optional<T>& opt) const {
     return opt == base::nullopt ? 0 : std::hash<T>()(*opt);
   }
 };
 
 }  // namespace std
 
 #endif  // BASE_OPTIONAL_H_