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() {}
+
+  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';
     T value_;
   };
 };
 
 template <typename T>
 struct OptionalStorage<T, true> {
-  OptionalStorage() {}
+  constexpr OptionalStorage() {}
+
+  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.
@@ skipping 16 matching lines @@
 // - Constructors do not use 'constexpr' as it is a C++14 extension.
 // - 'constexpr' might be missing in some places for reasons specified locally.
 // - No exceptions are thrown, because they are banned from Chromium.
 // - All the non-members are in the 'base' namespace instead of 'std'.
 template <typename T>
 class Optional {
  public:
   using value_type = T;
 
   constexpr Optional() = default;
-  Optional(base::nullopt_t) : Optional() {}
+
+  constexpr Optional(base::nullopt_t) {}
 
   Optional(const Optional& other) {
     if (!other.storage_.is_null_)
       Init(other.value());
   }
 
   Optional(Optional&& other) {
     if (!other.storage_.is_null_)
       Init(std::move(other.value()));
   }
 
-  Optional(const T& value) { Init(value); }
+  constexpr Optional(const T& value) : storage_(value) {}
 
-  Optional(T&& value) { Init(std::move(value)); }
+  // TODO(alshabalin): Can't use 'constexpr' with std::move until C++14.
+  Optional(T&& value) : storage_(std::move(value)) {}
 
+  // TODO(alshabalin): Can't use 'constexpr' with std::forward until C++14.
   template <class... Args>
-  explicit Optional(base::in_place_t, Args&&... args) {
-    emplace(std::forward<Args>(args)...);
-  }
+  explicit Optional(base::in_place_t, Args&&... args)
+      : storage_(base::in_place, std::forward<Args>(args)...) {}
 
   ~Optional() = default;
 
   Optional& operator=(base::nullopt_t) {
     FreeIfNeeded();
     return *this;
   }
 
   Optional& operator=(const Optional& other) {
     if (other.storage_.is_null_) {
@@ skipping 341 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_