Move optional.h to webrtc/api/

webrtc/api/optional.h

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#ifndef WEBRTC_RTC_BASE_OPTIONAL_H_
-#define WEBRTC_RTC_BASE_OPTIONAL_H_
+#ifndef WEBRTC_API_OPTIONAL_H_
+#define WEBRTC_API_OPTIONAL_H_
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 #ifdef UNIT_TEST
 #include <iomanip>
 #include <ostream>
 #endif  // UNIT_TEST
 
@@ skipping 14 matching lines @@
 
 template <typename T>
 inline T* FunctionThatDoesNothing(T* x) {
   return reinterpret_cast<T*>(
       FunctionThatDoesNothingImpl(reinterpret_cast<void*>(x)));
 }
 
 #else
 
 template <typename T>
-inline T* FunctionThatDoesNothing(T* x) { return x; }
+inline T* FunctionThatDoesNothing(T* x) {
+  return x;
+}
 
 #endif
 
 }  // namespace optional_internal
 
 // Simple std::optional-wannabe. It either contains a T or not.
 //
 // A moved-from Optional<T> may only be destroyed, and assigned to if T allows
 // being assigned to after having been moved from. Specifically, you may not
 // assume that it just doesn't contain a value anymore.
@@ skipping 31 matching lines @@
 //   and cleanest. (If you're *sure* that the the caller will always already
 //   have an Optional<T>, const Optional<T>& is slightly faster than const T*,
 //   but this is a micro-optimization. In general, stick to const T*.)
 //
 // TODO(kwiberg): Get rid of this class when the standard library has
 // std::optional (and we're allowed to use it).
 template <typename T>
 class Optional final {
  public:
   // Construct an empty Optional.
-  Optional() : has_value_(false), empty_('\0') {
-    PoisonValue();
-  }
+  Optional() : has_value_(false), empty_('\0') { PoisonValue(); }
 
   // Construct an Optional that contains a value.
   explicit Optional(const T& value) : has_value_(true) {
     new (&value_) T(value);
   }
   explicit Optional(T&& value) : has_value_(true) {
     new (&value_) T(std::move(value));
   }
 
   // Copy constructor: copies the value from m if it has one.
@@ skipping 174 matching lines @@
   }
 
  private:
   // Tell sanitizers that value_ shouldn't be touched.
   void PoisonValue() {
     rtc::AsanPoison(rtc::MakeArrayView(&value_, 1));
     rtc::MsanMarkUninitialized(rtc::MakeArrayView(&value_, 1));
   }
 
   // Tell sanitizers that value_ is OK to touch again.
-  void UnpoisonValue() {
-    rtc::AsanUnpoison(rtc::MakeArrayView(&value_, 1));
-  }
+  void UnpoisonValue() { rtc::AsanUnpoison(rtc::MakeArrayView(&value_, 1)); }
 
   bool has_value_;  // True iff value_ contains a live value.
   union {
     // empty_ exists only to make it possible to initialize the union, even when
     // it doesn't contain any data. If the union goes uninitialized, it may
     // trigger compiler warnings.
     char empty_;
     // By placing value_ in a union, we get to manage its construction and
     // destruction manually: the Optional constructors won't automatically
     // construct it, and the Optional destructor won't automatically destroy
@@ skipping 90 matching lines @@
     optional_internal::OptionalPrintToHelper(*opt, os);
   } else {
     *os << "<empty optional>";
   }
 }
 
 #endif  // UNIT_TEST
 
 }  // namespace rtc
 
-#endif  // WEBRTC_RTC_BASE_OPTIONAL_H_
+#endif  // WEBRTC_API_OPTIONAL_H_