Make base::Optional constructor constexpr.

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 {
-  OptionalStorage() {}
+  constexpr OptionalStorage() {}
   // 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';
     T value_;
   };
 };
 
 template <typename T>
 struct OptionalStorage<T, true> {
-  OptionalStorage() {}
+  constexpr OptionalStorage() {}
   // 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.
@@ skipping 397 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_