base::Optional: Use anonymous union instead of base::AlignedMemory

docs/optional.md

 # base::Optional
 
 `base::Optional<T>` is a container that might contain an instance of `T`.
 
 [TOC]
 
 ## History
 
 [base::Optional<T>](https://code.google.com/p/chromium/codesearch#chromium/src/base/optional.h)
 is an implementation of [std::optional<T>](http://en.cppreference.com/w/cpp/utility/optional),
@@ skipping 58 matching lines @@
 base::Optional<int> opt = make_optional<int>(GetMagicNumber());
 ```
 
 Finally, `base::Optional<T>` is integrated with `std::hash`, using
 `std::hash<T>` if it is not empty, a default value otherwise. `.emplace()` and
 `.swap()` can be used as members functions and `std::swap()` will work with two
 `base::Optional<T>` objects.
 
 ## How is it implemented?
 
-`base::Optional<T>` is implemented using `base::AlignedMemory`. The object
+`base::Optional<T>` is implemented with a union with a `T` member. The object
 doesn't behave like a pointer and doesn't do dynamic memory allocation. In
 other words, it is guaranteed to have an object allocated when it is not empty.
 
 ## When to use?
 
 A very common use case is for classes and structures that have an object not
 always available, because it is early initialized or because the underlying data
 structure doesn't require it.
 
 It is common to implement such patterns with dynamically allocated pointers,
 `nullptr` representing the absence of value. Other approaches involve
 `std::pair<T, bool>` where bool represents whether the object is actually
 present.
 
 It can also be used for simple types, for example when a structure wants to
 represent whether the user or the underlying data structure has some value
 unspecified, a `base::Optional<int>` would be easier to understand than a
 special value representing the lack of it. For example, using -1 as the
 undefined value when the expected value can't be negative.
 
 ## When not to use?
 
 It is recommended to not use `base::Optional<T>` as a function parameter as it
 will force the callers to use `base::Optional<T>`. Instead, it is recommended to
 keep using `T*` for arguments that can be ommited, with `nullptr` representing
 no value.
 
 Furthermore, depending on `T`, MSVC might fail to compile code using
 `base::Optional<T>` as a parameter because of memory alignment issues.