diff --git a/BUILD b/BUILD
index cb6b454..8cc1999 100644
--- a/BUILD
+++ b/BUILD
@@ -408,7 +408,6 @@
         "include/perfetto/ext/base/metatrace.h",
         "include/perfetto/ext/base/metatrace_events.h",
         "include/perfetto/ext/base/no_destructor.h",
-        "include/perfetto/ext/base/optional.h",
         "include/perfetto/ext/base/paged_memory.h",
         "include/perfetto/ext/base/periodic_task.h",
         "include/perfetto/ext/base/pipe.h",
diff --git a/include/perfetto/ext/base/BUILD.gn b/include/perfetto/ext/base/BUILD.gn
index 5a44be4..6e38737 100644
--- a/include/perfetto/ext/base/BUILD.gn
+++ b/include/perfetto/ext/base/BUILD.gn
@@ -32,7 +32,6 @@
     "metatrace.h",
     "metatrace_events.h",
     "no_destructor.h",
-    "optional.h",
     "paged_memory.h",
     "periodic_task.h",
     "pipe.h",
diff --git a/include/perfetto/ext/base/base64.h b/include/perfetto/ext/base/base64.h
index 030a83d..5a01164 100644
--- a/include/perfetto/ext/base/base64.h
+++ b/include/perfetto/ext/base/base64.h
@@ -17,9 +17,9 @@
 #ifndef INCLUDE_PERFETTO_EXT_BASE_BASE64_H_
 #define INCLUDE_PERFETTO_EXT_BASE_BASE64_H_
 
+#include <optional>
 #include <string>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/ext/base/utils.h"  // For ssize_t.
 
@@ -56,9 +56,9 @@
                      uint8_t* dst,
                      size_t dst_size);
 
-Optional<std::string> Base64Decode(const char* src, size_t src_size);
+std::optional<std::string> Base64Decode(const char* src, size_t src_size);
 
-inline Optional<std::string> Base64Decode(StringView sv) {
+inline std::optional<std::string> Base64Decode(StringView sv) {
   return Base64Decode(sv.data(), sv.size());
 }
 
diff --git a/include/perfetto/ext/base/http/http_server.h b/include/perfetto/ext/base/http/http_server.h
index c251061..2fe563b 100644
--- a/include/perfetto/ext/base/http/http_server.h
+++ b/include/perfetto/ext/base/http/http_server.h
@@ -21,10 +21,10 @@
 #include <initializer_list>
 #include <list>
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "perfetto/base/task_runner.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/paged_memory.h"
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/ext/base/unix_socket.h"
@@ -37,7 +37,7 @@
 struct HttpRequest {
   explicit HttpRequest(HttpServerConnection* c) : conn(c) {}
 
-  Optional<StringView> GetHeader(StringView name) const;
+  std::optional<StringView> GetHeader(StringView name) const;
 
   HttpServerConnection* conn;
 
diff --git a/include/perfetto/ext/base/optional.h b/include/perfetto/ext/base/optional.h
deleted file mode 100644
index 4ea781f..0000000
--- a/include/perfetto/ext/base/optional.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef INCLUDE_PERFETTO_EXT_BASE_OPTIONAL_H_
-#define INCLUDE_PERFETTO_EXT_BASE_OPTIONAL_H_
-
-#include <functional>
-#include <optional>
-
-namespace perfetto {
-namespace base {
-
-template <typename T>
-using Optional = std::optional<T>;
-
-inline constexpr std::nullopt_t nullopt = std::nullopt;
-
-template <class T>
-constexpr std::optional<std::decay_t<T>> make_optional(T&& value) {
-  return std::make_optional<T>(std::forward<T>(value));
-}
-
-template <class T, class... Args>
-constexpr std::optional<T> make_optional(Args&&... args) {
-  return std::make_optional<T>(std::forward<Args...>(args)...);
-}
-
-}  // namespace base
-}  // namespace perfetto
-
-#endif  // INCLUDE_PERFETTO_EXT_BASE_OPTIONAL_H_
diff --git a/include/perfetto/ext/base/status_or.h b/include/perfetto/ext/base/status_or.h
index 7067295..46387d7 100644
--- a/include/perfetto/ext/base/status_or.h
+++ b/include/perfetto/ext/base/status_or.h
@@ -17,8 +17,9 @@
 #ifndef INCLUDE_PERFETTO_EXT_BASE_STATUS_OR_H_
 #define INCLUDE_PERFETTO_EXT_BASE_STATUS_OR_H_
 
+#include <optional>
+
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 
 namespace perfetto {
 namespace base {
@@ -38,7 +39,7 @@
 
   // Intentionally implicit to allow idomatic usage (e.g. returning value/status
   // from base::StatusOr returning function).
-  StatusOr(base::Status status) : StatusOr(std::move(status), base::nullopt) {
+  StatusOr(base::Status status) : StatusOr(std::move(status), std::nullopt) {
     if (status.ok()) {
       // Matches what Abseil's approach towards OkStatus being passed to
       // absl::StatusOr<T>.
@@ -63,13 +64,13 @@
   const T* operator->() const { return &value(); }
 
  private:
-  StatusOr(base::Status status, base::Optional<T> value)
+  StatusOr(base::Status status, std::optional<T> value)
       : status_(std::move(status)), value_(std::move(value)) {
     PERFETTO_DCHECK(!status_.ok() || value_.has_value());
   }
 
   base::Status status_;
-  base::Optional<T> value_;
+  std::optional<T> value_;
 };
 
 }  // namespace base
diff --git a/include/perfetto/ext/base/string_utils.h b/include/perfetto/ext/base/string_utils.h
index 828d214..20e5799 100644
--- a/include/perfetto/ext/base/string_utils.h
+++ b/include/perfetto/ext/base/string_utils.h
@@ -22,10 +22,10 @@
 #include <string.h>
 
 #include <cinttypes>
+#include <optional>
 #include <string>
 #include <vector>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 
 namespace perfetto {
@@ -39,59 +39,63 @@
   return ('a' <= c && c <= 'z') ? static_cast<char>(c + ('A' - 'a')) : c;
 }
 
-inline Optional<uint32_t> CStringToUInt32(const char* s, int base = 10) {
+inline std::optional<uint32_t> CStringToUInt32(const char* s, int base = 10) {
   char* endptr = nullptr;
   auto value = static_cast<uint32_t>(strtoul(s, &endptr, base));
-  return (*s && !*endptr) ? base::make_optional(value) : base::nullopt;
+  return (*s && !*endptr) ? std::make_optional(value) : std::nullopt;
 }
 
-inline Optional<int32_t> CStringToInt32(const char* s, int base = 10) {
+inline std::optional<int32_t> CStringToInt32(const char* s, int base = 10) {
   char* endptr = nullptr;
   auto value = static_cast<int32_t>(strtol(s, &endptr, base));
-  return (*s && !*endptr) ? base::make_optional(value) : base::nullopt;
+  return (*s && !*endptr) ? std::make_optional(value) : std::nullopt;
 }
 
 // Note: it saturates to 7fffffffffffffff if parsing a hex number >= 0x8000...
-inline Optional<int64_t> CStringToInt64(const char* s, int base = 10) {
+inline std::optional<int64_t> CStringToInt64(const char* s, int base = 10) {
   char* endptr = nullptr;
   auto value = static_cast<int64_t>(strtoll(s, &endptr, base));
-  return (*s && !*endptr) ? base::make_optional(value) : base::nullopt;
+  return (*s && !*endptr) ? std::make_optional(value) : std::nullopt;
 }
 
-inline Optional<uint64_t> CStringToUInt64(const char* s, int base = 10) {
+inline std::optional<uint64_t> CStringToUInt64(const char* s, int base = 10) {
   char* endptr = nullptr;
   auto value = static_cast<uint64_t>(strtoull(s, &endptr, base));
-  return (*s && !*endptr) ? base::make_optional(value) : base::nullopt;
+  return (*s && !*endptr) ? std::make_optional(value) : std::nullopt;
 }
 
 double StrToD(const char* nptr, char** endptr);
 
-inline Optional<double> CStringToDouble(const char* s) {
+inline std::optional<double> CStringToDouble(const char* s) {
   char* endptr = nullptr;
   double value = StrToD(s, &endptr);
-  Optional<double> result(base::nullopt);
+  std::optional<double> result(std::nullopt);
   if (*s != '\0' && *endptr == '\0')
     result = value;
   return result;
 }
 
-inline Optional<uint32_t> StringToUInt32(const std::string& s, int base = 10) {
+inline std::optional<uint32_t> StringToUInt32(const std::string& s,
+                                              int base = 10) {
   return CStringToUInt32(s.c_str(), base);
 }
 
-inline Optional<int32_t> StringToInt32(const std::string& s, int base = 10) {
+inline std::optional<int32_t> StringToInt32(const std::string& s,
+                                            int base = 10) {
   return CStringToInt32(s.c_str(), base);
 }
 
-inline Optional<uint64_t> StringToUInt64(const std::string& s, int base = 10) {
+inline std::optional<uint64_t> StringToUInt64(const std::string& s,
+                                              int base = 10) {
   return CStringToUInt64(s.c_str(), base);
 }
 
-inline Optional<int64_t> StringToInt64(const std::string& s, int base = 10) {
+inline std::optional<int64_t> StringToInt64(const std::string& s,
+                                            int base = 10) {
   return CStringToInt64(s.c_str(), base);
 }
 
-inline Optional<double> StringToDouble(const std::string& s) {
+inline std::optional<double> StringToDouble(const std::string& s) {
   return CStringToDouble(s.c_str());
 }
 
@@ -177,10 +181,10 @@
 
 // For given string and offset Pfinds a line with character for
 // which offset points, what number is this line (starts from 1), and the offset
-// inside this line. returns nullopt if the offset points to
+// inside this line. returns std::nullopt if the offset points to
 // line break character or exceeds string length.
-base::Optional<LineWithOffset> FindLineWithOffset(base::StringView str,
-                                                  uint32_t offset);
+std::optional<LineWithOffset> FindLineWithOffset(base::StringView str,
+                                                 uint32_t offset);
 
 // A helper class to facilitate construction and usage of write-once stack
 // strings.
diff --git a/include/perfetto/ext/base/subprocess.h b/include/perfetto/ext/base/subprocess.h
index 6102832..12121e0 100644
--- a/include/perfetto/ext/base/subprocess.h
+++ b/include/perfetto/ext/base/subprocess.h
@@ -21,6 +21,7 @@
 #include <functional>
 #include <initializer_list>
 #include <mutex>
+#include <optional>
 #include <string>
 #include <thread>
 #include <vector>
@@ -30,7 +31,6 @@
 #include "perfetto/base/platform_handle.h"
 #include "perfetto/base/proc_utils.h"
 #include "perfetto/ext/base/event_fd.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/pipe.h"
 #include "perfetto/ext/base/scoped_file.h"
 
@@ -145,7 +145,7 @@
     // setpgid(0 /*self_pid*/, posix_proc_group_id).
     // This can be used to avoid that subprocesses receive CTRL-C from the
     // terminal, while still living in the same session.
-    base::Optional<pid_t> posix_proc_group_id{};
+    std::optional<pid_t> posix_proc_group_id{};
 #endif
 
     // If non-empty, replaces the environment passed to exec().
diff --git a/include/perfetto/ext/base/threading/channel.h b/include/perfetto/ext/base/threading/channel.h
index d117ff0..9bf42f5 100644
--- a/include/perfetto/ext/base/threading/channel.h
+++ b/include/perfetto/ext/base/threading/channel.h
@@ -18,12 +18,12 @@
 #define INCLUDE_PERFETTO_EXT_BASE_THREADING_CHANNEL_H_
 
 #include <mutex>
+#include <optional>
 
 #include "perfetto/base/compiler.h"
 #include "perfetto/base/platform_handle.h"
 #include "perfetto/ext/base/circular_queue.h"
 #include "perfetto/ext/base/event_fd.h"
-#include "perfetto/ext/base/optional.h"
 
 namespace perfetto {
 namespace base {
@@ -43,24 +43,24 @@
 class Channel {
  public:
   struct ReadResult {
-    ReadResult(base::Optional<T> _item, bool _is_closed)
+    ReadResult(std::optional<T> _item, bool _is_closed)
         : item(std::move(_item)), is_closed(_is_closed) {}
 
     bool operator==(const ReadResult& res) const {
       return item == res.item && is_closed == res.is_closed;
     }
 
-    // The item read from the channel or base::nullopt if the channel is empty.
+    // The item read from the channel or std::nullopt if the channel is empty.
     // If so, callers can use |read_fd| to be notified when a read operation
     // would succeed.
-    base::Optional<T> item;
+    std::optional<T> item;
 
     // Indicates the channel is closed. Readers can continue to read from the
     // channel and any buffered elements will be correctly returned. Moreover,
     // any future reads will also have |is_closed| == true and |read_fd| will be
     // ready forever.
     //
-    // Once a ReadResult is returned with |item| == base::nullopt and
+    // Once a ReadResult is returned with |item| == std::nullopt and
     // |is_closed| == true, no further values will ever be returned.
     bool is_closed;
   };
@@ -103,7 +103,7 @@
   PERFETTO_WARN_UNUSED_RESULT ReadResult ReadNonBlocking() {
     std::lock_guard<std::mutex> lock(mutex_);
     if (elements_.empty()) {
-      return ReadResult(base::nullopt, is_closed_);
+      return ReadResult(std::nullopt, is_closed_);
     }
     if (elements_.capacity() == elements_.size()) {
       write_fd_.Notify();
diff --git a/include/perfetto/ext/base/threading/future_combinators.h b/include/perfetto/ext/base/threading/future_combinators.h
index 40f7722..d726c66 100644
--- a/include/perfetto/ext/base/threading/future_combinators.h
+++ b/include/perfetto/ext/base/threading/future_combinators.h
@@ -17,11 +17,11 @@
 #ifndef INCLUDE_PERFETTO_EXT_BASE_THREADING_FUTURE_COMBINATORS_H_
 #define INCLUDE_PERFETTO_EXT_BASE_THREADING_FUTURE_COMBINATORS_H_
 
+#include <optional>
 #include <utility>
 #include <vector>
 
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/threading/poll.h"
 
 namespace perfetto {
@@ -57,17 +57,17 @@
     PERFETTO_CHECK((first_ && second_fn_) || second_);
     if (first_) {
       ASSIGN_OR_RETURN_IF_PENDING_FUTURE(res, first_->Poll(context));
-      first_ = nullopt;
+      first_ = std::nullopt;
       second_ = (*second_fn_)(std::move(res));
-      second_fn_ = base::nullopt;
+      second_fn_ = std::nullopt;
     }
     return second_->Poll(context);
   }
 
  private:
-  Optional<Future<A>> first_;
-  Optional<Function> second_fn_;
-  Optional<Future<B>> second_;
+  std::optional<Future<A>> first_;
+  std::optional<Function> second_fn_;
+  std::optional<Future<B>> second_;
 };
 
 }  // namespace base
diff --git a/include/perfetto/ext/base/threading/poll.h b/include/perfetto/ext/base/threading/poll.h
index 5989361..5a4b7e3 100644
--- a/include/perfetto/ext/base/threading/poll.h
+++ b/include/perfetto/ext/base/threading/poll.h
@@ -17,10 +17,11 @@
 #ifndef INCLUDE_PERFETTO_EXT_BASE_THREADING_POLL_H_
 #define INCLUDE_PERFETTO_EXT_BASE_THREADING_POLL_H_
 
+#include <optional>
+
 #include <variant>
 #include "perfetto/base/flat_set.h"
 #include "perfetto/base/platform_handle.h"
-#include "perfetto/ext/base/optional.h"
 
 namespace perfetto {
 namespace base {
diff --git a/include/perfetto/ext/base/threading/spawn.h b/include/perfetto/ext/base/threading/spawn.h
index bf73fb9..df2f8ec 100644
--- a/include/perfetto/ext/base/threading/spawn.h
+++ b/include/perfetto/ext/base/threading/spawn.h
@@ -22,6 +22,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <utility>
 #include <vector>
 
@@ -31,7 +32,6 @@
 #include "perfetto/base/task_runner.h"
 #include "perfetto/ext/base/event_fd.h"
 #include "perfetto/ext/base/flat_hash_map.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/thread_checker.h"
 #include "perfetto/ext/base/threading/channel.h"
 #include "perfetto/ext/base/threading/future.h"
@@ -110,7 +110,7 @@
     std::function<Stream<T>()> fn) {
   class AllVoidCollector : public Collector<FVoid, FVoid> {
    public:
-    Optional<FVoid> OnNext(FVoid) override { return nullopt; }
+    std::optional<FVoid> OnNext(FVoid) override { return std::nullopt; }
     FVoid OnDone() override { return FVoid(); }
   };
   auto channel = std::make_shared<Channel<T>>(4);
diff --git a/include/perfetto/ext/base/threading/stream_combinators.h b/include/perfetto/ext/base/threading/stream_combinators.h
index 5485139..2b7b69e 100644
--- a/include/perfetto/ext/base/threading/stream_combinators.h
+++ b/include/perfetto/ext/base/threading/stream_combinators.h
@@ -18,11 +18,11 @@
 #define INCLUDE_PERFETTO_EXT_BASE_THREADING_STREAM_COMBINATORS_H_
 
 #include <memory>
+#include <optional>
 #include <utility>
 #include <vector>
 
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/status_or.h"
 #include "perfetto/ext/base/threading/future_combinators.h"
 #include "perfetto/ext/base/threading/poll.h"
@@ -87,14 +87,14 @@
       future_ = map_fn_(std::move(res.item()));
     }
     ASSIGN_OR_RETURN_IF_PENDING_FUTURE(res, future_->Poll(context));
-    future_ = nullopt;
+    future_ = std::nullopt;
     return res;
   }
 
  private:
   Stream<T> stream_;
   Function map_fn_;
-  Optional<Future<U>> future_;
+  std::optional<Future<U>> future_;
 };
 
 // Implementation of a StreamPollable for creating a concatenating two streams
@@ -111,13 +111,13 @@
       if (!res.IsDone()) {
         return res.item();
       }
-      first_ = base::nullopt;
+      first_ = std::nullopt;
     }
     return second_.PollNext(context);
   }
 
  private:
-  base::Optional<Stream<T>> first_;
+  std::optional<Stream<T>> first_;
   Stream<T> second_;
 };
 
@@ -140,7 +140,7 @@
       if (!stream) {
         continue;
       }
-      Optional<PollContext> ctx = PollContextForStream(upstream, i);
+      std::optional<PollContext> ctx = PollContextForStream(upstream, i);
       if (!ctx) {
         continue;
       }
@@ -154,7 +154,7 @@
       }
       // StreamPollable has returned EOF. Clear it and the registered handles
       // out.
-      stream = nullopt;
+      stream = std::nullopt;
       ++eof_streams_;
       registered_handles_[i].clear();
     }
@@ -172,8 +172,8 @@
   }
 
  private:
-  Optional<PollContext> PollContextForStream(PollContext* upstream,
-                                             uint32_t stream_idx) {
+  std::optional<PollContext> PollContextForStream(PollContext* upstream,
+                                                  uint32_t stream_idx) {
     FlatSet<PlatformHandle>& state = registered_handles_[stream_idx];
     if (state.empty()) {
       return PollContext(&state, &upstream->ready_handles());
@@ -184,10 +184,10 @@
         return PollContext(&state, &upstream->ready_handles());
       }
     }
-    return base::nullopt;
+    return std::nullopt;
   }
 
-  std::vector<Optional<Stream<T>>> streams_;
+  std::vector<std::optional<Stream<T>>> streams_;
   std::vector<FlatSet<PlatformHandle>> registered_handles_;
   uint32_t eof_streams_ = 0;
 };
@@ -226,12 +226,12 @@
 
   // Receives the next item from a Stream<T>. If the wrapping Future<U> can be
   // completed, returns the a value U which completes that future. Otherwise,
-  // returns base::nullopt.
-  virtual Optional<U> OnNext(T value) = 0;
+  // returns std::nullopt.
+  virtual std::optional<U> OnNext(T value) = 0;
 
   // Called when the stream has completed and returns the |U| which will be
   // used to complete the future. This method will only be called if OnNext
-  // returned nullopt for every element in the stream.
+  // returned std::nullopt for every element in the stream.
   virtual U OnDone() = 0;
 };
 
@@ -250,7 +250,7 @@
       if (res.IsDone()) {
         return collector_->OnDone();
       }
-      Optional<U> collected = collector_->OnNext(std::move(res.item()));
+      std::optional<U> collected = collector_->OnNext(std::move(res.item()));
       if (collected.has_value()) {
         return std::move(collected.value());
       }
@@ -267,8 +267,8 @@
  public:
   ~AllOkCollectorImpl() override;
 
-  Optional<Status> OnNext(Status status) override {
-    return status.ok() ? nullopt : make_optional(std::move(status));
+  std::optional<Status> OnNext(Status status) override {
+    return status.ok() ? std::nullopt : std::make_optional(std::move(status));
   }
   Status OnDone() override { return OkStatus(); }
 };
@@ -277,15 +277,15 @@
 template <typename T>
 class FutureCheckedCollectorImpl : public Collector<T, T> {
  public:
-  Optional<T> OnNext(T value) override {
+  std::optional<T> OnNext(T value) override {
     PERFETTO_CHECK(!prev_value_);
     prev_value_ = value;
-    return nullopt;
+    return std::nullopt;
   }
   T OnDone() override { return *prev_value_; }
 
  private:
-  Optional<T> prev_value_;
+  std::optional<T> prev_value_;
 };
 
 // Implementation for |StatusOrVectorCollector|.
@@ -293,13 +293,13 @@
 class StatusOrVectorCollectorImpl
     : public Collector<base::StatusOr<T>, base::StatusOr<std::vector<T>>> {
  public:
-  Optional<base::StatusOr<std::vector<T>>> OnNext(
+  std::optional<base::StatusOr<std::vector<T>>> OnNext(
       base::StatusOr<T> val_or) override {
     if (!val_or.ok()) {
-      return make_optional(val_or.status());
+      return std::make_optional(val_or.status());
     }
     values_.emplace_back(std::move(val_or.value()));
-    return nullopt;
+    return std::nullopt;
   }
   base::StatusOr<std::vector<T>> OnDone() override {
     return std::move(values_);
diff --git a/include/perfetto/ext/base/threading/thread_pool.h b/include/perfetto/ext/base/threading/thread_pool.h
index 1a4b153..e08baaa 100644
--- a/include/perfetto/ext/base/threading/thread_pool.h
+++ b/include/perfetto/ext/base/threading/thread_pool.h
@@ -21,11 +21,11 @@
 #include <functional>
 #include <list>
 #include <mutex>
+#include <optional>
 #include <thread>
 #include <vector>
 
 #include "perfetto/base/task_runner.h"
-#include "perfetto/ext/base/optional.h"
 
 namespace perfetto {
 namespace base {
diff --git a/include/perfetto/ext/base/threading/util.h b/include/perfetto/ext/base/threading/util.h
index 34dccdb..7b2465e 100644
--- a/include/perfetto/ext/base/threading/util.h
+++ b/include/perfetto/ext/base/threading/util.h
@@ -19,13 +19,13 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 #include "perfetto/base/status.h"
 #include "perfetto/base/task_runner.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/threading/channel.h"
 #include "perfetto/ext/base/threading/future.h"
 #include "perfetto/ext/base/threading/poll.h"
@@ -104,7 +104,7 @@
 
 // Creates a Stream<T> which yields the result of executing |fn| on |pool|
 // repeatedly. The returned stream only completes when |fn| returns
-// base::nullopt.
+// std::nullopt.
 //
 // The intended usage of this function is to schedule CPU intensive work on a
 // background thread pool and receive regular "updates" on the progress by:
@@ -112,13 +112,13 @@
 // b) returning some indication of progress/partial results through |T|.
 template <typename T>
 Stream<T> RunOnThreadPool(ThreadPool* pool,
-                          std::function<base::Optional<T>()> fn) {
+                          std::function<std::optional<T>()> fn) {
   class RunOnPoolImpl : public StreamPollable<T> {
    public:
     explicit RunOnPoolImpl(ThreadPool* pool,
-                           std::function<base::Optional<T>()> fn)
+                           std::function<std::optional<T>()> fn)
         : pool_(pool),
-          fn_(std::make_shared<std::function<base::Optional<T>()>>(
+          fn_(std::make_shared<std::function<std::optional<T>()>>(
               std::move(fn))),
           channel_(new Channel<T>(1)),
           channel_stream_(ReadChannelStream(channel_.get())) {
@@ -150,7 +150,7 @@
     }
 
     ThreadPool* pool_ = nullptr;
-    std::shared_ptr<std::function<base::Optional<T>()>> fn_;
+    std::shared_ptr<std::function<std::optional<T>()>> fn_;
     std::shared_ptr<Channel<T>> channel_;
     base::Stream<T> channel_stream_;
   };
@@ -166,9 +166,9 @@
 Future<T> RunOnceOnThreadPool(ThreadPool* pool, std::function<T()> fn) {
   return RunOnThreadPool<T>(
              pool,
-             [done = false, fn = std::move(fn)]() mutable -> base::Optional<T> {
+             [done = false, fn = std::move(fn)]() mutable -> std::optional<T> {
                if (done) {
-                 return base::nullopt;
+                 return std::nullopt;
                }
                done = true;
                return fn();
diff --git a/include/perfetto/ext/base/uuid.h b/include/perfetto/ext/base/uuid.h
index 5e2e258..2bf5f5b 100644
--- a/include/perfetto/ext/base/uuid.h
+++ b/include/perfetto/ext/base/uuid.h
@@ -20,10 +20,9 @@
 #include <string.h>
 #include <array>
 #include <cstdint>
+#include <optional>
 #include <string>
 
-#include "perfetto/ext/base/optional.h"
-
 namespace perfetto {
 namespace base {
 
diff --git a/include/perfetto/ext/trace_processor/importers/memory_tracker/graph_processor.h b/include/perfetto/ext/trace_processor/importers/memory_tracker/graph_processor.h
index f7b02e7..2d702f7 100644
--- a/include/perfetto/ext/trace_processor/importers/memory_tracker/graph_processor.h
+++ b/include/perfetto/ext/trace_processor/importers/memory_tracker/graph_processor.h
@@ -80,7 +80,7 @@
   static void PropagateNumericsAndDiagnosticsRecursively(
       GlobalNodeGraph::Node* node);
 
-  static base::Optional<uint64_t> AggregateSizeForDescendantNode(
+  static std::optional<uint64_t> AggregateSizeForDescendantNode(
       GlobalNodeGraph::Node* root,
       GlobalNodeGraph::Node* descendant);
 
diff --git a/infra/perfetto.dev/src/gen_sql_tables_reference.js b/infra/perfetto.dev/src/gen_sql_tables_reference.js
index 9af1d32..2f77cea 100644
--- a/infra/perfetto.dev/src/gen_sql_tables_reference.js
+++ b/infra/perfetto.dev/src/gen_sql_tables_reference.js
@@ -111,7 +111,7 @@
     if (m = line.match(/^\s*C\(([^,]+)\s*,\s*(\w+)/)) {
       const col = getOrCreateColumn(/*name=*/ m[2]);
       col.type = m[1];
-      if (m = col.type.match(/Optional<(.*)>/)) {
+      if (m = col.type.match(/std::optional<(.*)>/)) {
         col.type = m[1];
         col.optional = true;
       }
@@ -168,7 +168,7 @@
     // C(StringPool::Id, name)                                    \
     // C(StackProfileMappingTable::Id, mapping)                   \
     // C(int64_t, rel_pc)                                         \
-    // C(base::Optional<uint32_t>, symbol_set_id)
+    // C(std::optional<uint32_t>, symbol_set_id)
     //
     // Where PERFETTO_TP_STACK_PROFILE_FRAME_DEF is |tableDefName|.
     let pattern = `(^[ ]*//.*\n)*`;
diff --git a/python/generators/trace_processor_table/serialize.py b/python/generators/trace_processor_table/serialize.py
index 4aee5b5..0a8715c 100644
--- a/python/generators/trace_processor_table/serialize.py
+++ b/python/generators/trace_processor_table/serialize.py
@@ -462,15 +462,15 @@
     {self.foreach_col(ColumnSerializer.shrink_to_fit)}
   }}
 
-  base::Optional<ConstRowReference> FindById(Id find_id) const {{
-    base::Optional<uint32_t> row = id().IndexOf(find_id);
-    return row ? base::make_optional(ConstRowReference(this, *row))
-               : base::nullopt;
+  std::optional<ConstRowReference> FindById(Id find_id) const {{
+    std::optional<uint32_t> row = id().IndexOf(find_id);
+    return row ? std::make_optional(ConstRowReference(this, *row))
+               : std::nullopt;
   }}
 
-  base::Optional<RowReference> FindById(Id find_id) {{
-    base::Optional<uint32_t> row = id().IndexOf(find_id);
-    return row ? base::make_optional(RowReference(this, *row)) : base::nullopt;
+  std::optional<RowReference> FindById(Id find_id) {{
+    std::optional<uint32_t> row = id().IndexOf(find_id);
+    return row ? std::make_optional(RowReference(this, *row)) : std::nullopt;
   }}
 
   IdAndRow Insert(const Row& row) {{
diff --git a/python/generators/trace_processor_table/util.py b/python/generators/trace_processor_table/util.py
index b6c38d8..015f02c 100644
--- a/python/generators/trace_processor_table/util.py
+++ b/python/generators/trace_processor_table/util.py
@@ -62,7 +62,7 @@
     else:
       cpp_type = self.cpp_type
     if self.is_optional:
-      return f'base::Optional<{cpp_type}>'
+      return f'std::optional<{cpp_type}>'
     return cpp_type
 
 
diff --git a/src/base/base64.cc b/src/base/base64.cc
index bb2e3c4..6b2236b 100644
--- a/src/base/base64.cc
+++ b/src/base/base64.cc
@@ -136,17 +136,17 @@
   return static_cast<ssize_t>(wr_size);
 }
 
-Optional<std::string> Base64Decode(const char* src, size_t src_size) {
+std::optional<std::string> Base64Decode(const char* src, size_t src_size) {
   std::string dst;
   dst.resize(Base64DecSize(src_size));
   auto res = Base64Decode(src, src_size, reinterpret_cast<uint8_t*>(&dst[0]),
                           dst.size());
   if (res < 0)
-    return nullopt;  // Decoding error.
+    return std::nullopt;  // Decoding error.
 
   PERFETTO_CHECK(res <= static_cast<ssize_t>(dst.size()));
   dst.resize(static_cast<size_t>(res));
-  return base::make_optional(dst);
+  return std::make_optional(dst);
 }
 
 }  // namespace base
diff --git a/src/base/base64_unittest.cc b/src/base/base64_unittest.cc
index fb131d9..f01b13c 100644
--- a/src/base/base64_unittest.cc
+++ b/src/base/base64_unittest.cc
@@ -341,14 +341,14 @@
 
   for (size_t i = 0; i < ArraySize(kPatterns); ++i) {
     const auto& p = kPatterns[i];
-    Optional<std::string> dec = Base64Decode(StringView(p.encoded));
+    std::optional<std::string> dec = Base64Decode(StringView(p.encoded));
     EXPECT_TRUE(dec.has_value());
     EXPECT_EQ(dec.value(), StringView(p.decoded, p.decoded_len).ToStdString());
   }
 
   // Error cases:
-  EXPECT_EQ(Base64Decode("Z"), nullopt);
-  EXPECT_EQ(Base64Decode("Zm9vY"), nullopt);
+  EXPECT_EQ(Base64Decode("Z"), std::nullopt);
+  EXPECT_EQ(Base64Decode("Zm9vY"), std::nullopt);
 
   uint8_t buf[4];
   EXPECT_EQ(Base64Decode("", 0, buf, 2), 0);       // Valid, 0 len.
diff --git a/src/base/file_utils.cc b/src/base/file_utils.cc
index 9f70ad7..e7d4c94 100644
--- a/src/base/file_utils.cc
+++ b/src/base/file_utils.cc
@@ -21,6 +21,7 @@
 
 #include <algorithm>
 #include <deque>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -28,7 +29,6 @@
 #include "perfetto/base/logging.h"
 #include "perfetto/base/platform_handle.h"
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/platform.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/utils.h"
@@ -54,11 +54,11 @@
   return FindClose(h) ? 0 : -1;
 }
 
-Optional<std::wstring> ToUtf16(const std::string str) {
+std::optional<std::wstring> ToUtf16(const std::string str) {
   int len = MultiByteToWideChar(CP_UTF8, 0, str.data(),
                                 static_cast<int>(str.size()), nullptr, 0);
   if (len < 0) {
-    return base::nullopt;
+    return std::nullopt;
   }
   std::vector<wchar_t> tmp;
   tmp.resize(static_cast<std::vector<wchar_t>::size_type>(len));
@@ -66,7 +66,7 @@
       MultiByteToWideChar(CP_UTF8, 0, str.data(), static_cast<int>(str.size()),
                           tmp.data(), static_cast<int>(tmp.size()));
   if (len < 0) {
-    return base::nullopt;
+    return std::nullopt;
   }
   PERFETTO_CHECK(static_cast<std::vector<wchar_t>::size_type>(len) ==
                  tmp.size());
diff --git a/src/base/http/http_server.cc b/src/base/http/http_server.cc
index 3db6ae2..2efe9f7 100644
--- a/src/base/http/http_server.cc
+++ b/src/base/http/http_server.cc
@@ -565,12 +565,12 @@
 
 HttpServerConnection::~HttpServerConnection() = default;
 
-Optional<StringView> HttpRequest::GetHeader(StringView name) const {
+std::optional<StringView> HttpRequest::GetHeader(StringView name) const {
   for (size_t i = 0; i < num_headers; i++) {
     if (headers[i].name.CaseInsensitiveEq(name))
       return headers[i].value;
   }
-  return nullopt;
+  return std::nullopt;
 }
 
 HttpRequestHandler::~HttpRequestHandler() = default;
diff --git a/src/base/string_utils.cc b/src/base/string_utils.cc
index 851b60c..ba6e52b 100644
--- a/src/base/string_utils.cc
+++ b/src/base/string_utils.cc
@@ -245,8 +245,8 @@
   return res;
 }
 
-base::Optional<LineWithOffset> FindLineWithOffset(base::StringView str,
-                                                  uint32_t offset) {
+std::optional<LineWithOffset> FindLineWithOffset(base::StringView str,
+                                                 uint32_t offset) {
   static constexpr char kNewLine = '\n';
   uint32_t line_offset = 0;
   uint32_t line_count = 1;
@@ -265,7 +265,7 @@
       return LineWithOffset{line, offset - line_offset, line_count};
     }
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 }  // namespace base
diff --git a/src/base/string_utils_unittest.cc b/src/base/string_utils_unittest.cc
index 2cc4b06..f65da9f 100644
--- a/src/base/string_utils_unittest.cc
+++ b/src/base/string_utils_unittest.cc
@@ -16,10 +16,9 @@
 
 #include "perfetto/ext/base/string_utils.h"
 
+#include <optional>
 #include "test/gtest_and_gmock.h"
 
-#include "perfetto/ext/base/optional.h"
-
 namespace perfetto {
 namespace base {
 namespace {
@@ -50,23 +49,23 @@
 }
 
 TEST(StringUtilsTest, CStringToUInt32) {
-  EXPECT_EQ(CStringToUInt32("0"), make_optional<uint32_t>(0U));
-  EXPECT_EQ(CStringToUInt32("1"), make_optional<uint32_t>(1U));
-  EXPECT_EQ(CStringToUInt32("42"), make_optional<uint32_t>(42U));
-  EXPECT_EQ(CStringToUInt32(""), nullopt);
-  EXPECT_EQ(CStringToUInt32("!?"), nullopt);
-  EXPECT_EQ(CStringToUInt32("abc"), nullopt);
-  EXPECT_EQ(CStringToUInt32("123 abc"), nullopt);
+  EXPECT_EQ(CStringToUInt32("0"), std::make_optional<uint32_t>(0U));
+  EXPECT_EQ(CStringToUInt32("1"), std::make_optional<uint32_t>(1U));
+  EXPECT_EQ(CStringToUInt32("42"), std::make_optional<uint32_t>(42U));
+  EXPECT_EQ(CStringToUInt32(""), std::nullopt);
+  EXPECT_EQ(CStringToUInt32("!?"), std::nullopt);
+  EXPECT_EQ(CStringToUInt32("abc"), std::nullopt);
+  EXPECT_EQ(CStringToUInt32("123 abc"), std::nullopt);
 }
 
 TEST(StringUtilsTest, CStringToInt32) {
-  EXPECT_EQ(CStringToInt32("0"), make_optional<int32_t>(0));
-  EXPECT_EQ(CStringToInt32("1"), make_optional<int32_t>(1));
-  EXPECT_EQ(CStringToInt32("-42"), make_optional<int32_t>(-42));
-  EXPECT_EQ(CStringToInt32(""), nullopt);
-  EXPECT_EQ(CStringToInt32("!?"), nullopt);
-  EXPECT_EQ(CStringToInt32("abc"), nullopt);
-  EXPECT_EQ(CStringToInt32("123 abc"), nullopt);
+  EXPECT_EQ(CStringToInt32("0"), std::make_optional<int32_t>(0));
+  EXPECT_EQ(CStringToInt32("1"), std::make_optional<int32_t>(1));
+  EXPECT_EQ(CStringToInt32("-42"), std::make_optional<int32_t>(-42));
+  EXPECT_EQ(CStringToInt32(""), std::nullopt);
+  EXPECT_EQ(CStringToInt32("!?"), std::nullopt);
+  EXPECT_EQ(CStringToInt32("abc"), std::nullopt);
+  EXPECT_EQ(CStringToInt32("123 abc"), std::nullopt);
 }
 
 TEST(StringUtilsTest, CStringToDouble) {
@@ -74,66 +73,68 @@
   EXPECT_DOUBLE_EQ(CStringToDouble("1").value(), 1l);
   EXPECT_DOUBLE_EQ(CStringToDouble("-42").value(), -42l);
   EXPECT_DOUBLE_EQ(CStringToDouble("-42.5").value(), -42.5l);
-  EXPECT_EQ(CStringToDouble(""), nullopt);
-  EXPECT_EQ(CStringToDouble("!?"), nullopt);
-  EXPECT_EQ(CStringToDouble("abc"), nullopt);
-  EXPECT_EQ(CStringToDouble("123 abc"), nullopt);
+  EXPECT_EQ(CStringToDouble(""), std::nullopt);
+  EXPECT_EQ(CStringToDouble("!?"), std::nullopt);
+  EXPECT_EQ(CStringToDouble("abc"), std::nullopt);
+  EXPECT_EQ(CStringToDouble("123 abc"), std::nullopt);
 }
 
 TEST(StringUtilsTest, StringToUInt32) {
-  EXPECT_EQ(StringToUInt32("0"), make_optional<uint32_t>(0U));
-  EXPECT_EQ(StringToUInt32("1"), make_optional<uint32_t>(1U));
-  EXPECT_EQ(StringToUInt32("42"), make_optional<uint32_t>(42U));
-  EXPECT_EQ(StringToUInt32("a", 16), make_optional<uint32_t>(10U));
+  EXPECT_EQ(StringToUInt32("0"), std::make_optional<uint32_t>(0U));
+  EXPECT_EQ(StringToUInt32("1"), std::make_optional<uint32_t>(1U));
+  EXPECT_EQ(StringToUInt32("42"), std::make_optional<uint32_t>(42U));
+  EXPECT_EQ(StringToUInt32("a", 16), std::make_optional<uint32_t>(10U));
   EXPECT_EQ(StringToUInt32("fffffff0", 16),
-            make_optional<uint32_t>(0xfffffff0));
-  EXPECT_EQ(StringToUInt32(""), nullopt);
-  EXPECT_EQ(StringToUInt32("!?"), nullopt);
-  EXPECT_EQ(StringToUInt32("abc"), nullopt);
-  EXPECT_EQ(StringToUInt32("123 abc"), nullopt);
-  EXPECT_EQ(StringToUInt32("beefz", 16), nullopt);
+            std::make_optional<uint32_t>(0xfffffff0));
+  EXPECT_EQ(StringToUInt32(""), std::nullopt);
+  EXPECT_EQ(StringToUInt32("!?"), std::nullopt);
+  EXPECT_EQ(StringToUInt32("abc"), std::nullopt);
+  EXPECT_EQ(StringToUInt32("123 abc"), std::nullopt);
+  EXPECT_EQ(StringToUInt32("beefz", 16), std::nullopt);
 }
 
 TEST(StringUtilsTest, StringToInt32) {
-  EXPECT_EQ(StringToInt32("0"), make_optional<int32_t>(0));
-  EXPECT_EQ(StringToInt32("1"), make_optional<int32_t>(1));
-  EXPECT_EQ(StringToInt32("-42"), make_optional<int32_t>(-42));
-  EXPECT_EQ(StringToInt32("42", 16), make_optional<int32_t>(0x42));
-  EXPECT_EQ(StringToInt32("7ffffffe", 16), make_optional<int32_t>(0x7ffffffe));
-  EXPECT_EQ(StringToInt32(""), nullopt);
-  EXPECT_EQ(StringToInt32("!?"), nullopt);
-  EXPECT_EQ(StringToInt32("abc"), nullopt);
-  EXPECT_EQ(StringToInt32("123 abc"), nullopt);
-  EXPECT_EQ(StringToInt32("beefz", 16), nullopt);
+  EXPECT_EQ(StringToInt32("0"), std::make_optional<int32_t>(0));
+  EXPECT_EQ(StringToInt32("1"), std::make_optional<int32_t>(1));
+  EXPECT_EQ(StringToInt32("-42"), std::make_optional<int32_t>(-42));
+  EXPECT_EQ(StringToInt32("42", 16), std::make_optional<int32_t>(0x42));
+  EXPECT_EQ(StringToInt32("7ffffffe", 16),
+            std::make_optional<int32_t>(0x7ffffffe));
+  EXPECT_EQ(StringToInt32(""), std::nullopt);
+  EXPECT_EQ(StringToInt32("!?"), std::nullopt);
+  EXPECT_EQ(StringToInt32("abc"), std::nullopt);
+  EXPECT_EQ(StringToInt32("123 abc"), std::nullopt);
+  EXPECT_EQ(StringToInt32("beefz", 16), std::nullopt);
 }
 
 TEST(StringUtilsTest, StringToUInt64) {
-  EXPECT_EQ(StringToUInt64("0"), make_optional<uint64_t>(0u));
-  EXPECT_EQ(StringToUInt64("1"), make_optional<uint64_t>(1u));
+  EXPECT_EQ(StringToUInt64("0"), std::make_optional<uint64_t>(0u));
+  EXPECT_EQ(StringToUInt64("1"), std::make_optional<uint64_t>(1u));
   EXPECT_EQ(StringToUInt64("5000000000"),
-            make_optional<uint64_t>(5000000000ULL));
+            std::make_optional<uint64_t>(5000000000ULL));
   EXPECT_EQ(StringToUInt64("7ffffffffffffffe", 16),
-            make_optional<uint64_t>(0x7ffffffffffffffeULL));
+            std::make_optional<uint64_t>(0x7ffffffffffffffeULL));
   EXPECT_EQ(StringToUInt64("9ffffffffffffffe", 16),
-            make_optional<uint64_t>(0x9ffffffffffffffeULL));
-  EXPECT_EQ(StringToUInt64(""), nullopt);
-  EXPECT_EQ(StringToUInt64("abc"), nullopt);
-  EXPECT_EQ(StringToUInt64("beefz", 16), nullopt);
+            std::make_optional<uint64_t>(0x9ffffffffffffffeULL));
+  EXPECT_EQ(StringToUInt64(""), std::nullopt);
+  EXPECT_EQ(StringToUInt64("abc"), std::nullopt);
+  EXPECT_EQ(StringToUInt64("beefz", 16), std::nullopt);
 }
 
 TEST(StringUtilsTest, StringToInt64) {
-  EXPECT_EQ(StringToInt64("0"), make_optional<int64_t>(0));
-  EXPECT_EQ(StringToInt64("1"), make_optional<int64_t>(1));
+  EXPECT_EQ(StringToInt64("0"), std::make_optional<int64_t>(0));
+  EXPECT_EQ(StringToInt64("1"), std::make_optional<int64_t>(1));
   EXPECT_EQ(StringToInt64("-5000000000"),
-            make_optional<int64_t>(-5000000000LL));
-  EXPECT_EQ(StringToInt64("5000000000"), make_optional<int64_t>(5000000000LL));
+            std::make_optional<int64_t>(-5000000000LL));
+  EXPECT_EQ(StringToInt64("5000000000"),
+            std::make_optional<int64_t>(5000000000LL));
   EXPECT_EQ(StringToInt64("7ffffffffffffffe", 16),
-            make_optional<int64_t>(0x7ffffffffffffffeLL));
+            std::make_optional<int64_t>(0x7ffffffffffffffeLL));
   EXPECT_EQ(StringToInt64("9ffffffe", 16),
-            make_optional<int64_t>(0x9ffffffeLL));
-  EXPECT_EQ(StringToInt64(""), nullopt);
-  EXPECT_EQ(StringToInt64("abc"), nullopt);
-  EXPECT_EQ(StringToInt64("beefz", 16), nullopt);
+            std::make_optional<int64_t>(0x9ffffffeLL));
+  EXPECT_EQ(StringToInt64(""), std::nullopt);
+  EXPECT_EQ(StringToInt64("abc"), std::nullopt);
+  EXPECT_EQ(StringToInt64("beefz", 16), std::nullopt);
 }
 
 TEST(StringUtilsTest, StringToDouble) {
@@ -143,13 +144,13 @@
   EXPECT_DOUBLE_EQ(StringToDouble("-42.5").value(), -42.5l);
   EXPECT_DOUBLE_EQ(StringToDouble("0.5").value(), .5l);
   EXPECT_DOUBLE_EQ(StringToDouble(".5").value(), .5l);
-  EXPECT_EQ(StringToDouble(""), nullopt);
-  EXPECT_EQ(StringToDouble("!?"), nullopt);
-  EXPECT_EQ(StringToDouble("abc"), nullopt);
-  EXPECT_EQ(StringToDouble("123 abc"), nullopt);
-  EXPECT_EQ(StringToDouble("124,456"), nullopt);
-  EXPECT_EQ(StringToDouble("4 2"), nullopt);
-  EXPECT_EQ(StringToDouble(" - 42"), nullopt);
+  EXPECT_EQ(StringToDouble(""), std::nullopt);
+  EXPECT_EQ(StringToDouble("!?"), std::nullopt);
+  EXPECT_EQ(StringToDouble("abc"), std::nullopt);
+  EXPECT_EQ(StringToDouble("123 abc"), std::nullopt);
+  EXPECT_EQ(StringToDouble("124,456"), std::nullopt);
+  EXPECT_EQ(StringToDouble("4 2"), std::nullopt);
+  EXPECT_EQ(StringToDouble(" - 42"), std::nullopt);
 }
 
 TEST(StringUtilsTest, StartsWith) {
diff --git a/src/base/threading/channel_unittest.cc b/src/base/threading/channel_unittest.cc
index 7acb355..2c5e45e 100644
--- a/src/base/threading/channel_unittest.cc
+++ b/src/base/threading/channel_unittest.cc
@@ -15,12 +15,13 @@
  */
 
 #include "perfetto/ext/base/threading/channel.h"
+
 #include <array>
 #include <memory>
+#include <optional>
 
 #include "perfetto/base/platform_handle.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/utils.h"
 #include "test/gtest_and_gmock.h"
 
@@ -71,7 +72,7 @@
   ASSERT_TRUE(IsReady(channel.read_fd()));
 
   ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(100, false));
-  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(base::nullopt, false));
+  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(std::nullopt, false));
 
   ASSERT_TRUE(IsReady(channel.write_fd()));
   ASSERT_FALSE(IsReady(channel.read_fd()));
@@ -98,7 +99,7 @@
   ASSERT_TRUE(IsReady(channel.write_fd()));
   ASSERT_FALSE(IsReady(channel.read_fd()));
 
-  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(base::nullopt, false));
+  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(std::nullopt, false));
   ASSERT_TRUE(IsReady(channel.write_fd()));
   ASSERT_FALSE(IsReady(channel.read_fd()));
 }
@@ -106,13 +107,13 @@
 TEST(ChannelUnittest, CloseEmptyChannel) {
   Channel<int> channel(1);
 
-  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(base::nullopt, false));
+  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(std::nullopt, false));
   ASSERT_FALSE(IsReady(channel.read_fd()));
 
   channel.Close();
 
-  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(base::nullopt, true));
-  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(base::nullopt, true));
+  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(std::nullopt, true));
+  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(std::nullopt, true));
 
   ASSERT_TRUE(IsReady(channel.read_fd()));
   ASSERT_TRUE(IsReady(channel.read_fd()));
@@ -139,12 +140,12 @@
 
 TEST(ChannelUnittest, ReadAfterClose) {
   Channel<int> channel(1);
-  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(base::nullopt, false));
+  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(std::nullopt, false));
   ASSERT_EQ(channel.WriteNonBlocking(100), WriteResult(true, false));
   channel.Close();
 
   ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(100, true));
-  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(base::nullopt, true));
+  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(std::nullopt, true));
 }
 
 TEST(ChannelUnittest, WriteAfterClose) {
@@ -164,7 +165,7 @@
   channel.Close();
   ASSERT_TRUE(IsReady(channel.write_fd()));
   ASSERT_TRUE(IsReady(channel.write_fd()));
-  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(base::nullopt, true));
+  ASSERT_EQ(channel.ReadNonBlocking(), ReadResult(std::nullopt, true));
   ASSERT_TRUE(IsReady(channel.write_fd()));
   ASSERT_TRUE(IsReady(channel.read_fd()));
 }
diff --git a/src/base/threading/spawn.cc b/src/base/threading/spawn.cc
index 4fd246a..e727f84 100644
--- a/src/base/threading/spawn.cc
+++ b/src/base/threading/spawn.cc
@@ -16,8 +16,9 @@
 
 #include "perfetto/ext/base/threading/spawn.h"
 
+#include <optional>
+
 #include "perfetto/base/task_runner.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/thread_checker.h"
 #include "perfetto/ext/base/threading/future.h"
 #include "perfetto/ext/base/threading/poll.h"
@@ -74,7 +75,7 @@
   }
 
   void ClearFutureAndWatches(FlatSet<PlatformHandle> interested) {
-    future_ = nullopt;
+    future_ = std::nullopt;
     for (PlatformHandle fd : interested) {
       task_runner_->RemoveFileDescriptorWatch(fd);
     }
@@ -94,7 +95,7 @@
 
   TaskRunner* const task_runner_ = nullptr;
 
-  Optional<Future<FVoid>> future_;
+  std::optional<Future<FVoid>> future_;
   FlatSet<PlatformHandle> interested_;
   FlatSet<PlatformHandle> ready_;
   PollContext context_{&interested_, &ready_};
diff --git a/src/base/threading/spawn_unittest.cc b/src/base/threading/spawn_unittest.cc
index 1324b18..a62ae83 100644
--- a/src/base/threading/spawn_unittest.cc
+++ b/src/base/threading/spawn_unittest.cc
@@ -16,8 +16,9 @@
 
 #include "perfetto/ext/base/threading/spawn.h"
 
+#include <optional>
+
 #include "perfetto/ext/base/event_fd.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/thread_task_runner.h"
 #include "perfetto/ext/base/threading/future.h"
 #include "perfetto/ext/base/threading/poll.h"
@@ -65,10 +66,10 @@
       });
 
   task_runner.RunUntilIdle();
-  ASSERT_EQ(res.channel()->ReadNonBlocking().item, base::nullopt);
+  ASSERT_EQ(res.channel()->ReadNonBlocking().item, std::nullopt);
 
   task_runner.RunUntilIdle();
-  ASSERT_EQ(res.channel()->ReadNonBlocking().item, base::nullopt);
+  ASSERT_EQ(res.channel()->ReadNonBlocking().item, std::nullopt);
 
   fd.Notify();
   task_runner.RunUntilIdle();
@@ -108,7 +109,7 @@
       });
 
   task_runner.RunUntilIdle();
-  ASSERT_EQ(res.channel()->ReadNonBlocking().item, base::nullopt);
+  ASSERT_EQ(res.channel()->ReadNonBlocking().item, std::nullopt);
 
   fd.Notify();
   task_runner.RunUntilIdle();
@@ -118,7 +119,7 @@
   ASSERT_FALSE(read.is_closed);
 
   task_runner.RunUntilIdle();
-  ASSERT_EQ(res.channel()->ReadNonBlocking().item, base::nullopt);
+  ASSERT_EQ(res.channel()->ReadNonBlocking().item, std::nullopt);
 
   fd.Notify();
   task_runner.RunUntilIdle();
diff --git a/src/base/threading/util_unittest.cc b/src/base/threading/util_unittest.cc
index 887802c..504435b 100644
--- a/src/base/threading/util_unittest.cc
+++ b/src/base/threading/util_unittest.cc
@@ -16,11 +16,12 @@
 
 #include "perfetto/ext/base/threading/util.h"
 
+#include <optional>
+
 #include "perfetto/base/flat_set.h"
 #include "perfetto/base/platform_handle.h"
 #include "perfetto/base/time.h"
 #include "perfetto/ext/base/event_fd.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/threading/channel.h"
 #include "perfetto/ext/base/threading/poll.h"
 #include "perfetto/ext/base/threading/stream.h"
@@ -45,7 +46,7 @@
   return res.item();
 }
 
-base::Optional<int> WaitForStreamReady(
+std::optional<int> WaitForStreamReady(
     base::Stream<int>& stream,
     base::FlatSet<base::PlatformHandle>& interested,
     PollContext& ctx) {
@@ -55,7 +56,7 @@
     base::BlockUntilReadableFd(*interested.begin());
     interested = {};
   }
-  return res.IsDone() ? base::nullopt : base::make_optional(res.item());
+  return res.IsDone() ? std::nullopt : std::make_optional(res.item());
 }
 
 TEST(UtilUnittest, BlockUntilReadableFd) {
@@ -113,7 +114,7 @@
   interested = {};
 
   ASSERT_EQ(channel.ReadNonBlocking().item, 1);
-  ASSERT_EQ(channel.ReadNonBlocking().item, base::nullopt);
+  ASSERT_EQ(channel.ReadNonBlocking().item, std::nullopt);
 
   ASSERT_FALSE(future.Poll(&ctx).IsPending());
   ASSERT_EQ(channel.ReadNonBlocking().item, 3);
@@ -127,11 +128,11 @@
   base::ThreadPool pool(1);
   base::Stream<int> stream =
       base::RunOnThreadPool<int>(&pool, [counter = 0]() mutable {
-        return counter == 2 ? base::nullopt : base::make_optional(counter++);
+        return counter == 2 ? std::nullopt : std::make_optional(counter++);
       });
   ASSERT_EQ(WaitForStreamReady(stream, interested, ctx), 0);
   ASSERT_EQ(WaitForStreamReady(stream, interested, ctx), 1);
-  ASSERT_EQ(WaitForStreamReady(stream, interested, ctx), base::nullopt);
+  ASSERT_EQ(WaitForStreamReady(stream, interested, ctx), std::nullopt);
 }
 
 TEST(UtilUnittest, RunOnceOnThreadPool) {
diff --git a/src/base/uuid_unittest.cc b/src/base/uuid_unittest.cc
index 9f5e52f..6cd22c9 100644
--- a/src/base/uuid_unittest.cc
+++ b/src/base/uuid_unittest.cc
@@ -16,9 +16,9 @@
 
 #include "perfetto/ext/base/uuid.h"
 
-#include "test/gtest_and_gmock.h"
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
+#include "test/gtest_and_gmock.h"
 
 namespace perfetto {
 namespace base {
diff --git a/src/kernel_utils/syscall_table.cc b/src/kernel_utils/syscall_table.cc
index ee7cccd..d5a6e23 100644
--- a/src/kernel_utils/syscall_table.cc
+++ b/src/kernel_utils/syscall_table.cc
@@ -98,13 +98,13 @@
   return SyscallTable(arch);
 }
 
-base::Optional<size_t> SyscallTable::GetByName(const std::string& name) const {
+std::optional<size_t> SyscallTable::GetByName(const std::string& name) const {
   for (size_t i = 0; i < syscall_count_; i++) {
     if (name == syscall_table_[i]) {
       return i;
     }
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 const char* SyscallTable::GetById(size_t id) const {
diff --git a/src/kernel_utils/syscall_table.h b/src/kernel_utils/syscall_table.h
index 3e88e0a..c2ec4a5 100644
--- a/src/kernel_utils/syscall_table.h
+++ b/src/kernel_utils/syscall_table.h
@@ -18,9 +18,9 @@
 #define SRC_KERNEL_UTILS_SYSCALL_TABLE_H_
 
 #include <memory>
+#include <optional>
 #include <string>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 
 namespace perfetto {
@@ -52,8 +52,8 @@
   static SyscallTable FromCurrentArch();
 
   // Returns the syscall id for the syscall with the given name. If the syscall
-  // is not found, returns nullopt.
-  base::Optional<size_t> GetByName(const std::string& name) const;
+  // is not found, returns std::nullopt.
+  std::optional<size_t> GetByName(const std::string& name) const;
 
   // Returns the syscall name for the syscall with the given id. If the syscall
   // is not found, returns nullptr.
diff --git a/src/perfetto_cmd/pbtxt_to_pb.cc b/src/perfetto_cmd/pbtxt_to_pb.cc
index 1904725..1f11a21 100644
--- a/src/perfetto_cmd/pbtxt_to_pb.cc
+++ b/src/perfetto_cmd/pbtxt_to_pb.cc
@@ -14,19 +14,18 @@
  * limitations under the License.
  */
 
-#include <ctype.h>
+#include "src/perfetto_cmd/pbtxt_to_pb.h"
 
+#include <ctype.h>
 #include <limits>
 #include <map>
+#include <optional>
 #include <set>
 #include <stack>
 #include <string>
 
-#include "src/perfetto_cmd/pbtxt_to_pb.h"
-
 #include "perfetto/base/logging.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/ext/base/utils.h"
@@ -442,7 +441,7 @@
   template <typename T>
   void FixedFloatField(const FieldDescriptorProto* field, Token t) {
     uint32_t field_id = static_cast<uint32_t>(field->number());
-    base::Optional<double> opt_n = base::StringToDouble(t.ToStdString());
+    std::optional<double> opt_n = base::StringToDouble(t.ToStdString());
     msg()->AppendFixed<T>(field_id, static_cast<T>(opt_n.value_or(0l)));
   }
 
diff --git a/src/perfetto_cmd/perfetto_cmd.cc b/src/perfetto_cmd/perfetto_cmd.cc
index a0234b8..4a2b081 100644
--- a/src/perfetto_cmd/perfetto_cmd.cc
+++ b/src/perfetto_cmd/perfetto_cmd.cc
@@ -155,7 +155,7 @@
 #endif  // PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD)
 }
 
-base::Optional<PerfettoStatsdAtom> ConvertRateLimiterResponseToAtom(
+std::optional<PerfettoStatsdAtom> ConvertRateLimiterResponseToAtom(
     RateLimiter::ShouldTraceResponse resp) {
   switch (resp) {
     case RateLimiter::kNotAllowedOnUserBuild:
@@ -167,7 +167,7 @@
     case RateLimiter::kHitUploadLimit:
       return PerfettoStatsdAtom::kCmdHitUploadLimit;
     case RateLimiter::kOkToTrace:
-      return base::nullopt;
+      return std::nullopt;
   }
   PERFETTO_FATAL("For GCC");
 }
@@ -270,8 +270,8 @@
           argv0);
 }
 
-base::Optional<int> PerfettoCmd::ParseCmdlineAndMaybeDaemonize(int argc,
-                                                               char** argv) {
+std::optional<int> PerfettoCmd::ParseCmdlineAndMaybeDaemonize(int argc,
+                                                              char** argv) {
 #if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
   umask(0000);  // make sure that file creation is not affected by umask.
 #endif
@@ -831,8 +831,8 @@
     background_wait_pipe_.rd.reset();
   }
 
-  return base::nullopt;  // Continues in ConnectToServiceRunAndMaybeNotify()
-                         // below.
+  return std::nullopt;  // Continues in ConnectToServiceRunAndMaybeNotify()
+                        // below.
 }
 
 void PerfettoCmd::NotifyBgProcessPipe(BgProcessStatus status) {
diff --git a/src/perfetto_cmd/perfetto_cmd.h b/src/perfetto_cmd/perfetto_cmd.h
index bd4a8c4..9504ca5 100644
--- a/src/perfetto_cmd/perfetto_cmd.h
+++ b/src/perfetto_cmd/perfetto_cmd.h
@@ -22,10 +22,10 @@
 #include <vector>
 
 #include <time.h>
+#include <optional>
 
 #include "perfetto/base/build_config.h"
 #include "perfetto/ext/base/event_fd.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/pipe.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/unix_task_runner.h"
@@ -52,10 +52,10 @@
   // with traced. This is to allow tools like tracebox to avoid spawning the
   // service for no reason if the cmdline parsing fails.
   // Return value:
-  //   nullopt: no error, the caller should call
+  //   std::nullopt: no error, the caller should call
   //   ConnectToServiceRunAndMaybeNotify.
   //   0-N: the caller should exit() with the given exit code.
-  base::Optional<int> ParseCmdlineAndMaybeDaemonize(int argc, char** argv);
+  std::optional<int> ParseCmdlineAndMaybeDaemonize(int argc, char** argv);
   int ConnectToServiceRunAndMaybeNotify();
 
   // perfetto::Consumer implementation.
@@ -157,7 +157,7 @@
   bool upload_flag_ = false;
   bool connected_ = false;
   std::string uuid_;
-  base::Optional<TracingSessionID> clone_tsid_{};
+  std::optional<TracingSessionID> clone_tsid_{};
 
   // How long we expect to trace for or 0 if the trace is indefinite.
   uint32_t expected_duration_ms_ = 0;
diff --git a/src/profiling/common/proc_cmdline.cc b/src/profiling/common/proc_cmdline.cc
index a6f7d93..d76ebfb 100644
--- a/src/profiling/common/proc_cmdline.cc
+++ b/src/profiling/common/proc_cmdline.cc
@@ -49,7 +49,7 @@
 // Keep them as STL-free as possible to allow for both implementations to be
 // close to verbatim copies.
 
-// TODO(rsavitski): consider changing to Optional<> return type.
+// TODO(rsavitski): consider changing to std::optional<> return type.
 bool ReadProcCmdlineForPID(pid_t pid, std::string* cmdline_out) {
   std::string filename = "/proc/" + std::to_string(pid) + "/cmdline";
   base::ScopedFile fd(base::OpenFile(filename, O_RDONLY));
diff --git a/src/profiling/common/proc_utils.cc b/src/profiling/common/proc_utils.cc
index 4188b2a..83fbb4a 100644
--- a/src/profiling/common/proc_utils.cc
+++ b/src/profiling/common/proc_utils.cc
@@ -20,9 +20,9 @@
 #include <unistd.h>
 
 #include <cinttypes>
+#include <optional>
 
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "src/profiling/common/proc_cmdline.h"
 
@@ -30,8 +30,8 @@
 namespace profiling {
 namespace {
 
-base::Optional<uint32_t> ParseProcStatusSize(const std::string& status,
-                                             const std::string& key) {
+std::optional<uint32_t> ParseProcStatusSize(const std::string& status,
+                                            const std::string& key) {
   auto entry_idx = status.find(key);
   if (entry_idx == std::string::npos)
     return {};
@@ -47,32 +47,32 @@
 }
 }  // namespace
 
-base::Optional<std::string> ReadStatus(pid_t pid) {
+std::optional<std::string> ReadStatus(pid_t pid) {
   std::string path = "/proc/" + std::to_string(pid) + "/status";
   std::string status;
   bool read_proc = base::ReadFile(path, &status);
   if (!read_proc) {
     PERFETTO_ELOG("Failed to read %s", path.c_str());
-    return base::nullopt;
+    return std::nullopt;
   }
-  return base::Optional<std::string>(status);
+  return std::optional<std::string>(status);
 }
 
-base::Optional<uint32_t> GetRssAnonAndSwap(const std::string& status) {
+std::optional<uint32_t> GetRssAnonAndSwap(const std::string& status) {
   auto anon_rss = ParseProcStatusSize(status, "RssAnon:");
   auto swap = ParseProcStatusSize(status, "VmSwap:");
   if (anon_rss.has_value() && swap.has_value()) {
     return *anon_rss + *swap;
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 void RemoveUnderAnonThreshold(uint32_t min_size_kb, std::set<pid_t>* pids) {
   for (auto it = pids->begin(); it != pids->end();) {
     const pid_t pid = *it;
 
-    base::Optional<std::string> status = ReadStatus(pid);
-    base::Optional<uint32_t> rss_and_swap;
+    std::optional<std::string> status = ReadStatus(pid);
+    std::optional<uint32_t> rss_and_swap;
     if (status)
       rss_and_swap = GetRssAnonAndSwap(*status);
 
@@ -87,10 +87,10 @@
   }
 }
 
-base::Optional<Uids> GetUids(const std::string& status) {
+std::optional<Uids> GetUids(const std::string& status) {
   auto entry_idx = status.find("Uid:");
   if (entry_idx == std::string::npos)
-    return base::nullopt;
+    return std::nullopt;
 
   Uids uids;
   const char* str = &status[entry_idx + 4];
@@ -98,22 +98,22 @@
 
   uids.real = strtoull(str, &endptr, 10);
   if (*endptr != ' ' && *endptr != '\t')
-    return base::nullopt;
+    return std::nullopt;
 
   str = endptr;
   uids.effective = strtoull(str, &endptr, 10);
   if (*endptr != ' ' && *endptr != '\t')
-    return base::nullopt;
+    return std::nullopt;
 
   str = endptr;
   uids.saved_set = strtoull(str, &endptr, 10);
   if (*endptr != ' ' && *endptr != '\t')
-    return base::nullopt;
+    return std::nullopt;
 
   str = endptr;
   uids.filesystem = strtoull(str, &endptr, 10);
   if (*endptr != '\n' && *endptr != '\0')
-    return base::nullopt;
+    return std::nullopt;
   return uids;
 }
 
@@ -146,7 +146,7 @@
   return first_arg - start;
 }
 
-base::Optional<std::vector<std::string>> NormalizeCmdlines(
+std::optional<std::vector<std::string>> NormalizeCmdlines(
     const std::vector<std::string>& cmdlines) {
   std::vector<std::string> normalized_cmdlines;
   normalized_cmdlines.reserve(cmdlines.size());
@@ -160,11 +160,11 @@
     if (size == -1) {
       PERFETTO_PLOG("Failed to normalize cmdline %s. Stopping the parse.",
                     cmdlines[i].c_str());
-      return base::nullopt;
+      return std::nullopt;
     }
     normalized_cmdlines.emplace_back(cmdline_cstr, static_cast<size_t>(size));
   }
-  return base::make_optional(normalized_cmdlines);
+  return std::make_optional(normalized_cmdlines);
 }
 
 // This is mostly the same as GetHeapprofdProgramProperty in
diff --git a/src/profiling/common/proc_utils.h b/src/profiling/common/proc_utils.h
index ccbf633..4792feb 100644
--- a/src/profiling/common/proc_utils.h
+++ b/src/profiling/common/proc_utils.h
@@ -20,10 +20,10 @@
 #include <sys/types.h>
 
 #include <cinttypes>
+#include <optional>
 #include <set>
 #include <vector>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 
 namespace perfetto {
@@ -53,13 +53,13 @@
   }
 }
 
-base::Optional<std::string> ReadStatus(pid_t pid);
-base::Optional<uint32_t> GetRssAnonAndSwap(const std::string&);
+std::optional<std::string> ReadStatus(pid_t pid);
+std::optional<uint32_t> GetRssAnonAndSwap(const std::string&);
 // Filters the list of pids (in-place), keeping only the
 // entries satisfying the minimum size criteria for anonymous memory.
 void RemoveUnderAnonThreshold(uint32_t min_size_kb, std::set<pid_t>* pids);
 
-base::Optional<Uids> GetUids(const std::string&);
+std::optional<Uids> GetUids(const std::string&);
 
 void FindAllProfilablePids(std::set<pid_t>* pids);
 
@@ -68,7 +68,7 @@
 // implementations are placed in the "glob_aware" namespace here, until we
 // migrate to one implementation for all profilers.
 ssize_t NormalizeCmdLine(char** cmdline_ptr, size_t size);
-base::Optional<std::vector<std::string>> NormalizeCmdlines(
+std::optional<std::vector<std::string>> NormalizeCmdlines(
     const std::vector<std::string>& cmdlines);
 void FindPidsForCmdlines(const std::vector<std::string>& cmdlines,
                          std::set<pid_t>* pids);
diff --git a/src/profiling/common/proc_utils_unittest.cc b/src/profiling/common/proc_utils_unittest.cc
index 36a7720..8ce34e4 100644
--- a/src/profiling/common/proc_utils_unittest.cc
+++ b/src/profiling/common/proc_utils_unittest.cc
@@ -15,7 +15,8 @@
  */
 
 #include "src/profiling/common/proc_utils.h"
-#include "perfetto/ext/base/optional.h"
+
+#include <optional>
 
 #include "perfetto/ext/base/utils.h"
 #include "test/gtest_and_gmock.h"
@@ -131,9 +132,9 @@
 }
 
 TEST(ProcUtilsTest, GetRssAnonAndSwapInvalidInput) {
-  EXPECT_EQ(GetRssAnonAndSwap(""), base::nullopt);
-  EXPECT_EQ(GetRssAnonAndSwap("RssAnon: 10000 kB"), base::nullopt);
-  EXPECT_EQ(GetRssAnonAndSwap("VmSwap: 10000"), base::nullopt);
+  EXPECT_EQ(GetRssAnonAndSwap(""), std::nullopt);
+  EXPECT_EQ(GetRssAnonAndSwap("RssAnon: 10000 kB"), std::nullopt);
+  EXPECT_EQ(GetRssAnonAndSwap("VmSwap: 10000"), std::nullopt);
 }
 
 TEST(ProcUtilsTest, GetUids) {
@@ -141,7 +142,7 @@
       "Name: foo\nRssAnon:  10000 kB\nVmSwap:\t10000 kB\n"
       "Uid: 1 2 3 4\n";
   auto uids = GetUids(status);
-  ASSERT_NE(uids, base::nullopt);
+  ASSERT_NE(uids, std::nullopt);
   EXPECT_EQ(uids->real, 1u);
   EXPECT_EQ(uids->effective, 2u);
   EXPECT_EQ(uids->saved_set, 3u);
@@ -153,7 +154,7 @@
       "Name: foo\nRssAnon:  10000 kB\nVmSwap:\t10000 kB\n"
       "Uid: 1a 2 3 4\n";
   auto uids = GetUids(status);
-  EXPECT_EQ(uids, base::nullopt);
+  EXPECT_EQ(uids, std::nullopt);
 }
 
 TEST(ProcUtilsTest, GetUidsInvalidTooFew) {
@@ -161,7 +162,7 @@
       "Name: foo\nRssAnon:  10000 kB\nVmSwap:\t10000 kB\n"
       "Uid: 1 2 3\n";
   auto uids = GetUids(status);
-  EXPECT_EQ(uids, base::nullopt);
+  EXPECT_EQ(uids, std::nullopt);
 }
 
 }  // namespace
diff --git a/src/profiling/common/producer_support.cc b/src/profiling/common/producer_support.cc
index a160149..5303658 100644
--- a/src/profiling/common/producer_support.cc
+++ b/src/profiling/common/producer_support.cc
@@ -16,9 +16,10 @@
 
 #include "src/profiling/common/producer_support.h"
 
+#include <optional>
+
 #include "perfetto/ext/base/android_utils.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/tracing/core/data_source_config.h"
 #include "src/traced/probes/packages_list/packages_list_parser.h"
@@ -27,26 +28,26 @@
 namespace profiling {
 
 namespace {
-base::Optional<Package> FindInPackagesList(
+std::optional<Package> FindInPackagesList(
     uint64_t lookup_uid,
     const std::string& packages_list_path) {
   std::string content;
   if (!base::ReadFile(packages_list_path, &content)) {
     PERFETTO_ELOG("Failed to read %s", packages_list_path.c_str());
-    return base::nullopt;
+    return std::nullopt;
   }
   for (base::StringSplitter ss(std::move(content), '\n'); ss.Next();) {
     Package pkg;
     if (!ReadPackagesListLine(ss.cur_token(), &pkg)) {
       PERFETTO_ELOG("Failed to parse packages.list");
-      return base::nullopt;
+      return std::nullopt;
     }
 
     if (pkg.uid == lookup_uid) {
       return std::move(pkg);  // -Wreturn-std-move-in-c++11
     }
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 bool AllPackagesProfileableByTrustedInitiator(
@@ -156,7 +157,7 @@
     return false;
   }
 
-  base::Optional<Package> pkg =
+  std::optional<Package> pkg =
       FindInPackagesList(uid_for_lookup, packages_list_path);
 
   if (!pkg)
diff --git a/src/profiling/common/profiler_guardrails.cc b/src/profiling/common/profiler_guardrails.cc
index a7f5dad..38ff6ed 100644
--- a/src/profiling/common/profiler_guardrails.cc
+++ b/src/profiling/common/profiler_guardrails.cc
@@ -17,29 +17,29 @@
 #include "src/profiling/common/profiler_guardrails.h"
 
 #include <unistd.h>
-
 #include <algorithm>
+#include <optional>
+
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/watchdog_posix.h"
 
 namespace perfetto {
 namespace profiling {
 
-base::Optional<uint64_t> GetCputimeSecForCurrentProcess() {
+std::optional<uint64_t> GetCputimeSecForCurrentProcess() {
   return GetCputimeSecForCurrentProcess(
       base::OpenFile("/proc/self/stat", O_RDONLY));
 }
 
-base::Optional<uint64_t> GetCputimeSecForCurrentProcess(
+std::optional<uint64_t> GetCputimeSecForCurrentProcess(
     base::ScopedFile stat_fd) {
   if (!stat_fd)
-    return base::nullopt;
+    return std::nullopt;
   base::ProcStat stat;
   if (!ReadProcStat(stat_fd.get(), &stat)) {
     PERFETTO_ELOG("Failed to read stat file to enforce guardrails.");
-    return base::nullopt;
+    return std::nullopt;
   }
   return (stat.utime + stat.stime) /
          static_cast<unsigned long>(sysconf(_SC_CLK_TCK));
diff --git a/src/profiling/common/profiler_guardrails.h b/src/profiling/common/profiler_guardrails.h
index e9e9d47..4fc723f 100644
--- a/src/profiling/common/profiler_guardrails.h
+++ b/src/profiling/common/profiler_guardrails.h
@@ -21,9 +21,9 @@
 #include <unistd.h>
 
 #include <cinttypes>
+#include <optional>
 
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/tracing/core/basic_types.h"
 #include "src/profiling/common/proc_utils.h"
@@ -31,14 +31,14 @@
 namespace perfetto {
 namespace profiling {
 
-base::Optional<uint64_t> GetCputimeSecForCurrentProcess();
+std::optional<uint64_t> GetCputimeSecForCurrentProcess();
 // For testing.
-base::Optional<uint64_t> GetCputimeSecForCurrentProcess(
+std::optional<uint64_t> GetCputimeSecForCurrentProcess(
     base::ScopedFile stat_fd);
 
 struct GuardrailConfig {
   uint64_t cpu_guardrail_sec = 0;
-  base::Optional<uint64_t> cpu_start_secs;
+  std::optional<uint64_t> cpu_start_secs;
   uint32_t memory_guardrail_kb = 0;
 };
 
@@ -51,7 +51,7 @@
   bool IsOverCpuThreshold(const GuardrailConfig& ds);
 
  private:
-  base::Optional<uint64_t> opt_cputime_sec_;
+  std::optional<uint64_t> opt_cputime_sec_;
 };
 
 class ProfilerMemoryGuardrails {
@@ -63,7 +63,7 @@
   bool IsOverMemoryThreshold(const GuardrailConfig& ds);
 
  private:
-  base::Optional<uint32_t> anon_and_swap_;
+  std::optional<uint32_t> anon_and_swap_;
 };
 
 }  // namespace profiling
diff --git a/src/profiling/common/profiler_guardrails_unittest.cc b/src/profiling/common/profiler_guardrails_unittest.cc
index ca9d1b2..1368cbe 100644
--- a/src/profiling/common/profiler_guardrails_unittest.cc
+++ b/src/profiling/common/profiler_guardrails_unittest.cc
@@ -20,9 +20,9 @@
 
 #include <cinttypes>
 #include <map>
+#include <optional>
 
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/temp_file.h"
 #include "test/gtest_and_gmock.h"
 
diff --git a/src/profiling/deobfuscator.cc b/src/profiling/deobfuscator.cc
index 378677e..fa32706 100644
--- a/src/profiling/deobfuscator.cc
+++ b/src/profiling/deobfuscator.cc
@@ -16,12 +16,12 @@
 
 #include "src/profiling/deobfuscator.h"
 
+#include <optional>
 #include "perfetto/base/status.h"
 #include "perfetto/ext/base/file_utils.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/string_splitter.h"
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/protozero/scattered_heap_buffer.h"
 #include "protos/perfetto/trace/profiling/deobfuscation.pbzero.h"
 #include "protos/perfetto/trace/trace.pbzero.h"
@@ -36,39 +36,39 @@
   std::string deobfuscated_name;
 };
 
-base::Optional<ProguardClass> ParseClass(std::string line) {
+std::optional<ProguardClass> ParseClass(std::string line) {
   base::StringSplitter ss(std::move(line), ' ');
 
   if (!ss.Next()) {
     PERFETTO_ELOG("Missing deobfuscated name.");
-    return base::nullopt;
+    return std::nullopt;
   }
   std::string deobfuscated_name(ss.cur_token(), ss.cur_token_size());
 
   if (!ss.Next() || ss.cur_token_size() != 2 ||
       strncmp("->", ss.cur_token(), 2) != 0) {
     PERFETTO_ELOG("Missing ->");
-    return base::nullopt;
+    return std::nullopt;
   }
 
   if (!ss.Next()) {
     PERFETTO_ELOG("Missing obfuscated name.");
-    return base::nullopt;
+    return std::nullopt;
   }
   std::string obfuscated_name(ss.cur_token(), ss.cur_token_size());
   if (obfuscated_name.empty()) {
     PERFETTO_ELOG("Empty obfuscated name.");
-    return base::nullopt;
+    return std::nullopt;
   }
   if (obfuscated_name.back() != ':') {
     PERFETTO_ELOG("Expected colon.");
-    return base::nullopt;
+    return std::nullopt;
   }
 
   obfuscated_name.resize(obfuscated_name.size() - 1);
   if (ss.Next()) {
     PERFETTO_ELOG("Unexpected data.");
-    return base::nullopt;
+    return std::nullopt;
   }
   return ProguardClass{std::move(obfuscated_name),
                        std::move(deobfuscated_name)};
@@ -85,36 +85,36 @@
   std::string deobfuscated_name;
 };
 
-base::Optional<ProguardMember> ParseMember(std::string line) {
+std::optional<ProguardMember> ParseMember(std::string line) {
   base::StringSplitter ss(std::move(line), ' ');
 
   if (!ss.Next()) {
     PERFETTO_ELOG("Missing type name.");
-    return base::nullopt;
+    return std::nullopt;
   }
   std::string type_name(ss.cur_token(), ss.cur_token_size());
 
   if (!ss.Next()) {
     PERFETTO_ELOG("Missing deobfuscated name.");
-    return base::nullopt;
+    return std::nullopt;
   }
   std::string deobfuscated_name(ss.cur_token(), ss.cur_token_size());
 
   if (!ss.Next() || ss.cur_token_size() != 2 ||
       strncmp("->", ss.cur_token(), 2) != 0) {
     PERFETTO_ELOG("Missing ->");
-    return base::nullopt;
+    return std::nullopt;
   }
 
   if (!ss.Next()) {
     PERFETTO_ELOG("Missing obfuscated name.");
-    return base::nullopt;
+    return std::nullopt;
   }
   std::string obfuscated_name(ss.cur_token(), ss.cur_token_size());
 
   if (ss.Next()) {
     PERFETTO_ELOG("Unexpected data.");
-    return base::nullopt;
+    return std::nullopt;
   }
 
   ProguardMemberType member_type;
diff --git a/src/profiling/memory/client.cc b/src/profiling/memory/client.cc
index 79e1a77..478a900 100644
--- a/src/profiling/memory/client.cc
+++ b/src/profiling/memory/client.cc
@@ -140,21 +140,21 @@
 }
 
 // static
-base::Optional<base::UnixSocketRaw> Client::ConnectToHeapprofd(
+std::optional<base::UnixSocketRaw> Client::ConnectToHeapprofd(
     const std::string& sock_name) {
   auto sock = base::UnixSocketRaw::CreateMayFail(base::SockFamily::kUnix,
                                                  base::SockType::kStream);
   if (!sock || !sock.Connect(sock_name)) {
     PERFETTO_PLOG("Failed to connect to %s", sock_name.c_str());
-    return base::nullopt;
+    return std::nullopt;
   }
   if (!sock.SetTxTimeout(kClientSockTimeoutMs)) {
     PERFETTO_PLOG("Failed to set send timeout for %s", sock_name.c_str());
-    return base::nullopt;
+    return std::nullopt;
   }
   if (!sock.SetRxTimeout(kClientSockTimeoutMs)) {
     PERFETTO_PLOG("Failed to set receive timeout for %s", sock_name.c_str());
-    return base::nullopt;
+    return std::nullopt;
   }
   return std::move(sock);
 }
diff --git a/src/profiling/memory/client.h b/src/profiling/memory/client.h
index 8b5f341..0e209fb 100644
--- a/src/profiling/memory/client.h
+++ b/src/profiling/memory/client.h
@@ -74,7 +74,7 @@
       base::UnixSocketRaw sock,
       UnhookedAllocator<Client> unhooked_allocator);
 
-  static base::Optional<base::UnixSocketRaw> ConnectToHeapprofd(
+  static std::optional<base::UnixSocketRaw> ConnectToHeapprofd(
       const std::string& sock_name);
 
   bool RecordMalloc(uint32_t heap_id,
diff --git a/src/profiling/memory/client_api_factory_android.cc b/src/profiling/memory/client_api_factory_android.cc
index 16c3a25..9c7b63c 100644
--- a/src/profiling/memory/client_api_factory_android.cc
+++ b/src/profiling/memory/client_api_factory_android.cc
@@ -23,9 +23,9 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <optional>
 
 #include "perfetto/base/build_config.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/unix_socket.h"
 #include "src/profiling/memory/client.h"
 
@@ -43,7 +43,7 @@
   PERFETTO_LOG("Constructing client for central daemon.");
   using perfetto::profiling::Client;
 
-  perfetto::base::Optional<perfetto::base::UnixSocketRaw> sock =
+  std::optional<perfetto::base::UnixSocketRaw> sock =
       Client::ConnectToHeapprofd(perfetto::profiling::kHeapprofdSocketFile);
   if (!sock) {
     PERFETTO_ELOG("Failed to connect to %s. This is benign on user builds.",
diff --git a/src/profiling/memory/heapprofd_end_to_end_test.cc b/src/profiling/memory/heapprofd_end_to_end_test.cc
index de9f40e..66acd81 100644
--- a/src/profiling/memory/heapprofd_end_to_end_test.cc
+++ b/src/profiling/memory/heapprofd_end_to_end_test.cc
@@ -25,11 +25,11 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <optional>
 
 #include "perfetto/base/build_config.h"
 #include "perfetto/base/logging.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/pipe.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/subprocess.h"
@@ -97,7 +97,7 @@
   int64_t cumulative_alloc_count;
   int64_t alloc_size;
   int64_t cumulative_alloc_size;
-  base::Optional<int64_t> parent_id;
+  std::optional<int64_t> parent_id;
 };
 
 std::vector<FlamegraphNode> GetFlamegraph(trace_processor::TraceProcessor* tp) {
@@ -116,8 +116,8 @@
         it.Get(8).AsLong(),
         it.Get(9).AsLong(),
         it.Get(10).AsLong(),
-        it.Get(11).is_null() ? base::nullopt
-                             : base::Optional<int64_t>(it.Get(11).AsLong()),
+        it.Get(11).is_null() ? std::nullopt
+                             : std::optional<int64_t>(it.Get(11).AsLong()),
     });
   }
   PERFETTO_CHECK(it.Status().ok());
diff --git a/src/profiling/memory/heapprofd_producer.cc b/src/profiling/memory/heapprofd_producer.cc
index 2d35965..7d0cfe8 100644
--- a/src/profiling/memory/heapprofd_producer.cc
+++ b/src/profiling/memory/heapprofd_producer.cc
@@ -24,12 +24,12 @@
 #include <algorithm>
 #include <cinttypes>
 #include <functional>
+#include <optional>
 #include <string>
 
 #include "perfetto/base/compiler.h"
 #include "perfetto/base/logging.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/thread_task_runner.h"
@@ -390,7 +390,7 @@
     return;
   }
 
-  base::Optional<std::vector<std::string>> normalized_cmdlines =
+  std::optional<std::vector<std::string>> normalized_cmdlines =
       NormalizeCmdlines(heapprofd_config.process_cmdline());
   if (!normalized_cmdlines.has_value()) {
     PERFETTO_ELOG("Rejecting data source due to invalid cmdline in config.");
@@ -416,7 +416,7 @@
     }
   }
 
-  base::Optional<uint64_t> start_cputime_sec;
+  std::optional<uint64_t> start_cputime_sec;
   if (heapprofd_config.max_heapprofd_cpu_secs() > 0) {
     start_cputime_sec = GetCputimeSecForCurrentProcess();
 
diff --git a/src/profiling/memory/heapprofd_producer.h b/src/profiling/memory/heapprofd_producer.h
index 92f830a..ac18b54 100644
--- a/src/profiling/memory/heapprofd_producer.h
+++ b/src/profiling/memory/heapprofd_producer.h
@@ -21,10 +21,10 @@
 #include <cinttypes>
 #include <functional>
 #include <map>
+#include <optional>
 #include <vector>
 
 #include "perfetto/base/task_runner.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/unix_socket.h"
 #include "perfetto/ext/base/unix_task_runner.h"
 #include "perfetto/ext/tracing/core/basic_types.h"
@@ -317,7 +317,7 @@
 
   // Specific to mode_ == kChild
   Process target_process_{base::kInvalidPid, ""};
-  base::Optional<std::function<void()>> data_source_callback_;
+  std::optional<std::function<void()>> data_source_callback_;
 
   SocketDelegate socket_delegate_;
 
diff --git a/src/profiling/memory/heapprofd_producer_integrationtest.cc b/src/profiling/memory/heapprofd_producer_integrationtest.cc
index 077a539..d0ea2c4 100644
--- a/src/profiling/memory/heapprofd_producer_integrationtest.cc
+++ b/src/profiling/memory/heapprofd_producer_integrationtest.cc
@@ -181,7 +181,7 @@
   tmpdir_.TrackFile("producer.sock");
   tmpdir_.TrackFile("consumer.sock");
 
-  base::Optional<TracingServiceThread> tracing_service;
+  std::optional<TracingServiceThread> tracing_service;
   tracing_service.emplace(tmpdir_.AbsolutePath("producer.sock"),
                           tmpdir_.AbsolutePath("consumer.sock"));
 
@@ -193,7 +193,7 @@
       StartHeapprofdTrace(tmpdir_.AbsolutePath("consumer.sock"), &task_runner);
   ASSERT_THAT(consumer, NotNull());
 
-  base::Optional<base::UnixSocketRaw> client_sock =
+  std::optional<base::UnixSocketRaw> client_sock =
       perfetto::profiling::Client::ConnectToHeapprofd(
           tmpdir_.AbsolutePath("heapprofd.sock"));
   ASSERT_TRUE(client_sock.has_value());
diff --git a/src/profiling/memory/java_hprof_producer.cc b/src/profiling/memory/java_hprof_producer.cc
index 81a9c27..01bd01c 100644
--- a/src/profiling/memory/java_hprof_producer.cc
+++ b/src/profiling/memory/java_hprof_producer.cc
@@ -18,8 +18,8 @@
 
 #include <signal.h>
 #include <limits>
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/tracing/core/trace_writer.h"
 #include "src/profiling/common/proc_cmdline.h"
 #include "src/profiling/common/proc_utils.h"
diff --git a/src/profiling/memory/shared_ring_buffer.cc b/src/profiling/memory/shared_ring_buffer.cc
index 3cc02e2..32d9b3c 100644
--- a/src/profiling/memory/shared_ring_buffer.cc
+++ b/src/profiling/memory/shared_ring_buffer.cc
@@ -186,7 +186,7 @@
   PERFETTO_DCHECK(spinlock.locked());
   Buffer result;
 
-  base::Optional<PointerPositions> opt_pos = GetPointerPositions();
+  std::optional<PointerPositions> opt_pos = GetPointerPositions();
   if (!opt_pos) {
     meta_->stats.num_writes_corrupt++;
     errno = EBADF;
@@ -245,7 +245,7 @@
 }
 
 SharedRingBuffer::Buffer SharedRingBuffer::BeginRead() {
-  base::Optional<PointerPositions> opt_pos = GetPointerPositions();
+  std::optional<PointerPositions> opt_pos = GetPointerPositions();
   if (!opt_pos) {
     meta_->stats.num_reads_corrupt++;
     errno = EBADF;
@@ -322,20 +322,20 @@
 }
 
 // static
-base::Optional<SharedRingBuffer> SharedRingBuffer::Create(size_t size) {
+std::optional<SharedRingBuffer> SharedRingBuffer::Create(size_t size) {
   auto buf = SharedRingBuffer(CreateFlag(), size);
   if (!buf.is_valid())
-    return base::nullopt;
-  return base::make_optional(std::move(buf));
+    return std::nullopt;
+  return std::make_optional(std::move(buf));
 }
 
 // static
-base::Optional<SharedRingBuffer> SharedRingBuffer::Attach(
+std::optional<SharedRingBuffer> SharedRingBuffer::Attach(
     base::ScopedFile mem_fd) {
   auto buf = SharedRingBuffer(AttachFlag(), std::move(mem_fd));
   if (!buf.is_valid())
-    return base::nullopt;
-  return base::make_optional(std::move(buf));
+    return std::nullopt;
+  return std::make_optional(std::move(buf));
 }
 
 }  // namespace profiling
diff --git a/src/profiling/memory/shared_ring_buffer.h b/src/profiling/memory/shared_ring_buffer.h
index 5bdb28e..9bc2e26 100644
--- a/src/profiling/memory/shared_ring_buffer.h
+++ b/src/profiling/memory/shared_ring_buffer.h
@@ -16,8 +16,8 @@
 
 #ifndef SRC_PROFILING_MEMORY_SHARED_RING_BUFFER_H_
 #define SRC_PROFILING_MEMORY_SHARED_RING_BUFFER_H_
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/unix_socket.h"
 #include "perfetto/ext/base/utils.h"
 #include "src/profiling/memory/scoped_spinlock.h"
@@ -97,8 +97,8 @@
     PERFETTO_CROSS_ABI_ALIGNED(ErrorState) error_state;
   };
 
-  static base::Optional<SharedRingBuffer> Create(size_t);
-  static base::Optional<SharedRingBuffer> Attach(base::ScopedFile);
+  static std::optional<SharedRingBuffer> Create(size_t);
+  static std::optional<SharedRingBuffer> Attach(base::ScopedFile);
 
   ~SharedRingBuffer();
   SharedRingBuffer() = default;
@@ -228,7 +228,7 @@
   void Initialize(base::ScopedFile mem_fd);
   bool IsCorrupt(const PointerPositions& pos);
 
-  inline base::Optional<PointerPositions> GetPointerPositions() {
+  inline std::optional<PointerPositions> GetPointerPositions() {
     PointerPositions pos;
     // We need to acquire load the write_pos to make sure we observe a
     // consistent ring buffer in BeginRead, otherwise it is possible that we
@@ -239,7 +239,7 @@
     pos.write_pos = meta_->write_pos.load(std::memory_order_acquire);
     pos.read_pos = meta_->read_pos.load(std::memory_order_relaxed);
 
-    base::Optional<PointerPositions> result;
+    std::optional<PointerPositions> result;
     if (IsCorrupt(pos))
       return result;
     result = pos;
diff --git a/src/profiling/memory/shared_ring_buffer_unittest.cc b/src/profiling/memory/shared_ring_buffer_unittest.cc
index 7f58b90..ff533f3 100644
--- a/src/profiling/memory/shared_ring_buffer_unittest.cc
+++ b/src/profiling/memory/shared_ring_buffer_unittest.cc
@@ -18,11 +18,11 @@
 
 #include <array>
 #include <mutex>
+#include <optional>
 #include <random>
 #include <thread>
 #include <unordered_map>
 
-#include "perfetto/ext/base/optional.h"
 #include "test/gtest_and_gmock.h"
 
 namespace perfetto {
@@ -147,18 +147,18 @@
 
 TEST(SharedRingBufferTest, ReadShutdown) {
   constexpr auto kBufSize = base::kPageSize * 4;
-  base::Optional<SharedRingBuffer> wr = SharedRingBuffer::Create(kBufSize);
+  std::optional<SharedRingBuffer> wr = SharedRingBuffer::Create(kBufSize);
   ASSERT_TRUE(wr);
   SharedRingBuffer rd =
       *SharedRingBuffer::Attach(base::ScopedFile(dup(wr->fd())));
   auto buf = rd.BeginRead();
-  wr = base::nullopt;
+  wr = std::nullopt;
   rd.EndRead(std::move(buf));
 }
 
 TEST(SharedRingBufferTest, WriteShutdown) {
   constexpr auto kBufSize = base::kPageSize * 4;
-  base::Optional<SharedRingBuffer> rd = SharedRingBuffer::Create(kBufSize);
+  std::optional<SharedRingBuffer> rd = SharedRingBuffer::Create(kBufSize);
   ASSERT_TRUE(rd);
   SharedRingBuffer wr =
       *SharedRingBuffer::Attach(base::ScopedFile(dup(rd->fd())));
@@ -167,21 +167,21 @@
     auto lock = wr.AcquireLock(ScopedSpinlock::Mode::Blocking);
     buf = wr.BeginWrite(lock, 10);
   }
-  rd = base::nullopt;
+  rd = std::nullopt;
   memset(buf.data, 0, buf.size);
   wr.EndWrite(std::move(buf));
 }
 
 TEST(SharedRingBufferTest, SingleThreadSameInstance) {
   constexpr auto kBufSize = base::kPageSize * 4;
-  base::Optional<SharedRingBuffer> buf = SharedRingBuffer::Create(kBufSize);
+  std::optional<SharedRingBuffer> buf = SharedRingBuffer::Create(kBufSize);
   StructuredTest(&*buf, &*buf);
 }
 
 TEST(SharedRingBufferTest, SingleThreadAttach) {
   constexpr auto kBufSize = base::kPageSize * 4;
-  base::Optional<SharedRingBuffer> buf1 = SharedRingBuffer::Create(kBufSize);
-  base::Optional<SharedRingBuffer> buf2 =
+  std::optional<SharedRingBuffer> buf1 = SharedRingBuffer::Create(kBufSize);
+  std::optional<SharedRingBuffer> buf2 =
       SharedRingBuffer::Attach(base::ScopedFile(dup(buf1->fd())));
   StructuredTest(&*buf1, &*buf2);
 }
@@ -256,13 +256,13 @@
 
 TEST(SharedRingBufferTest, InvalidSize) {
   constexpr auto kBufSize = base::kPageSize * 4 + 1;
-  base::Optional<SharedRingBuffer> wr = SharedRingBuffer::Create(kBufSize);
-  EXPECT_EQ(wr, base::nullopt);
+  std::optional<SharedRingBuffer> wr = SharedRingBuffer::Create(kBufSize);
+  EXPECT_EQ(wr, std::nullopt);
 }
 
 TEST(SharedRingBufferTest, EmptyWrite) {
   constexpr auto kBufSize = base::kPageSize * 4;
-  base::Optional<SharedRingBuffer> wr = SharedRingBuffer::Create(kBufSize);
+  std::optional<SharedRingBuffer> wr = SharedRingBuffer::Create(kBufSize);
   ASSERT_TRUE(wr);
   SharedRingBuffer::Buffer buf;
   {
diff --git a/src/profiling/perf/event_config.cc b/src/profiling/perf/event_config.cc
index a89d0c9..25b05c3 100644
--- a/src/profiling/perf/event_config.cc
+++ b/src/profiling/perf/event_config.cc
@@ -20,10 +20,10 @@
 #include <time.h>
 
 #include <unwindstack/Regs.h>
+#include <optional>
 #include <vector>
 
 #include "perfetto/base/flat_set.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/utils.h"
 #include "src/profiling/perf/regs_parsing.h"
 
@@ -56,7 +56,7 @@
 }
 
 // If set, the returned id is guaranteed to be non-zero.
-base::Optional<uint32_t> ParseTracepointAndResolveId(
+std::optional<uint32_t> ParseTracepointAndResolveId(
     const protos::gen::PerfEvents::Tracepoint& tracepoint,
     EventConfig::tracepoint_id_fn_t tracepoint_id_lookup) {
   std::string full_name = tracepoint.name();
@@ -68,7 +68,7 @@
         "Invalid tracepoint format: %s. Should be a full path like "
         "sched:sched_switch or sched/sched_switch.",
         full_name.c_str());
-    return base::nullopt;
+    return std::nullopt;
   }
 
   uint32_t tracepoint_id = tracepoint_id_lookup(tp_group, tp_name);
@@ -77,9 +77,9 @@
         "Failed to resolve tracepoint %s to its id. Check that tracefs is "
         "accessible and the event exists.",
         full_name.c_str());
-    return base::nullopt;
+    return std::nullopt;
   }
-  return base::make_optional(tracepoint_id);
+  return std::make_optional(tracepoint_id);
 }
 
 // |T| is either gen::PerfEventConfig or gen::PerfEventConfig::Scope.
@@ -91,7 +91,7 @@
 template <typename T>
 TargetFilter ParseTargetFilter(
     const T& cfg,
-    base::Optional<ProcessSharding> process_sharding) {
+    std::optional<ProcessSharding> process_sharding) {
   TargetFilter filter;
   for (const auto& str : cfg.target_cmdline()) {
     filter.cmdlines.push_back(str);
@@ -114,22 +114,22 @@
   return (v != 0 && ((v & (v - 1)) == 0));
 }
 
-// returns |base::nullopt| if the input is invalid.
-base::Optional<uint32_t> ChooseActualRingBufferPages(uint32_t config_value) {
+// returns |std::nullopt| if the input is invalid.
+std::optional<uint32_t> ChooseActualRingBufferPages(uint32_t config_value) {
   if (!config_value) {
     static_assert(IsPowerOfTwo(kDefaultDataPagesPerRingBuffer), "");
-    return base::make_optional(kDefaultDataPagesPerRingBuffer);
+    return std::make_optional(kDefaultDataPagesPerRingBuffer);
   }
 
   if (!IsPowerOfTwo(config_value)) {
     PERFETTO_ELOG("kernel buffer size must be a power of two pages");
-    return base::nullopt;
+    return std::nullopt;
   }
 
-  return base::make_optional(config_value);
+  return std::make_optional(config_value);
 }
 
-base::Optional<PerfCounter> ToPerfCounter(
+std::optional<PerfCounter> ToPerfCounter(
     std::string name,
     protos::gen::PerfEvents::Counter pb_enum) {
   using protos::gen::PerfEvents;
@@ -218,7 +218,7 @@
     default:
       PERFETTO_ELOG("Unrecognised PerfEvents::Counter enum value: %zu",
                     static_cast<size_t>(pb_enum));
-      return base::nullopt;
+      return std::nullopt;
   }
 }
 
@@ -294,10 +294,10 @@
 }
 
 // static
-base::Optional<EventConfig> EventConfig::Create(
+std::optional<EventConfig> EventConfig::Create(
     const protos::gen::PerfEventConfig& pb_config,
     const DataSourceConfig& raw_ds_config,
-    base::Optional<ProcessSharding> process_sharding,
+    std::optional<ProcessSharding> process_sharding,
     tracepoint_id_fn_t tracepoint_id_lookup) {
   // Timebase: sampling interval.
   uint64_t sampling_frequency = 0;
@@ -321,15 +321,15 @@
     auto maybe_counter =
         ToPerfCounter(timebase_name, pb_config.timebase().counter());
     if (!maybe_counter)
-      return base::nullopt;
+      return std::nullopt;
     timebase_event = *maybe_counter;
 
   } else if (pb_config.timebase().has_tracepoint()) {
     const auto& tracepoint_pb = pb_config.timebase().tracepoint();
-    base::Optional<uint32_t> maybe_id =
+    std::optional<uint32_t> maybe_id =
         ParseTracepointAndResolveId(tracepoint_pb, tracepoint_id_lookup);
     if (!maybe_id)
-      return base::nullopt;
+      return std::nullopt;
     timebase_event = PerfCounter::Tracepoint(
         timebase_name, tracepoint_pb.name(), tracepoint_pb.filter(), *maybe_id);
 
@@ -370,7 +370,7 @@
         // enum value from the future that we don't yet know, refuse the config
         // TODO(rsavitski): double-check that both pbzero and ::gen propagate
         // unknown enum values.
-        return base::nullopt;
+        return std::nullopt;
     }
 
     // Process scoping. Sharding parameter is supplied from outside as it is
@@ -388,10 +388,10 @@
   }
 
   // Ring buffer options.
-  base::Optional<uint32_t> ring_buffer_pages =
+  std::optional<uint32_t> ring_buffer_pages =
       ChooseActualRingBufferPages(pb_config.ring_buffer_pages());
   if (!ring_buffer_pages.has_value())
-    return base::nullopt;
+    return std::nullopt;
 
   uint32_t read_tick_period_ms = pb_config.ring_buffer_read_period_ms()
                                      ? pb_config.ring_buffer_read_period_ms()
@@ -421,7 +421,7 @@
   PERFETTO_DLOG("Capping samples (not records) per tick to [%" PRIu64 "]",
                 samples_per_tick_limit);
   if (samples_per_tick_limit == 0)
-    return base::nullopt;
+    return std::nullopt;
 
   // Optional footprint controls.
   uint64_t max_enqueued_footprint_bytes =
diff --git a/src/profiling/perf/event_config.h b/src/profiling/perf/event_config.h
index 515a102..dd1a7e3 100644
--- a/src/profiling/perf/event_config.h
+++ b/src/profiling/perf/event_config.h
@@ -25,9 +25,9 @@
 #include <linux/perf_event.h>
 #include <stdint.h>
 #include <sys/types.h>
+#include <optional>
 
 #include "perfetto/base/flat_set.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/tracing/core/data_source_config.h"
 
 #include "protos/perfetto/common/perf_events.gen.h"
@@ -56,7 +56,7 @@
   std::vector<std::string> exclude_cmdlines;
   base::FlatSet<pid_t> pids;
   base::FlatSet<pid_t> exclude_pids;
-  base::Optional<ProcessSharding> process_sharding;
+  std::optional<ProcessSharding> process_sharding;
   uint32_t additional_cmdline_count = 0;
 };
 
@@ -118,10 +118,10 @@
   using tracepoint_id_fn_t =
       std::function<uint32_t(const std::string&, const std::string&)>;
 
-  static base::Optional<EventConfig> Create(
+  static std::optional<EventConfig> Create(
       const protos::gen::PerfEventConfig& pb_config,
       const DataSourceConfig& raw_ds_config,
-      base::Optional<ProcessSharding> process_sharding,
+      std::optional<ProcessSharding> process_sharding,
       tracepoint_id_fn_t tracepoint_id_lookup);
 
   uint32_t ring_buffer_pages() const { return ring_buffer_pages_; }
diff --git a/src/profiling/perf/event_config_unittest.cc b/src/profiling/perf/event_config_unittest.cc
index 95c0a9b..35ec628 100644
--- a/src/profiling/perf/event_config_unittest.cc
+++ b/src/profiling/perf/event_config_unittest.cc
@@ -19,9 +19,9 @@
 #include <linux/perf_event.h>
 #include <stdint.h>
 #include <time.h>
+#include <optional>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "test/gtest_and_gmock.h"
 
 #include "protos/perfetto/common/perf_events.gen.h"
@@ -38,20 +38,20 @@
   return (v != 0 && ((v & (v - 1)) == 0));
 }
 
-base::Optional<EventConfig> CreateEventConfig(
+std::optional<EventConfig> CreateEventConfig(
     const protos::gen::PerfEventConfig& perf_cfg,
     EventConfig::tracepoint_id_fn_t tracepoint_id_lookup =
         [](const std::string&, const std::string&) { return 0; }) {
   protos::gen::DataSourceConfig ds_cfg;
   ds_cfg.set_perf_event_config_raw(perf_cfg.SerializeAsString());
   return EventConfig::Create(perf_cfg, ds_cfg,
-                             /*process_sharding=*/base::nullopt,
+                             /*process_sharding=*/std::nullopt,
                              tracepoint_id_lookup);
 }
 
 TEST(EventConfigTest, AttrStructConstructed) {
   protos::gen::PerfEventConfig cfg;
-  base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+  std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
   ASSERT_TRUE(event_config.has_value());
   ASSERT_TRUE(event_config->perf_attr() != nullptr);
@@ -60,7 +60,7 @@
 TEST(EventConfigTest, RingBufferPagesValidated) {
   {  // if unset, a default is used
     protos::gen::PerfEventConfig cfg;
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     ASSERT_GT(event_config->ring_buffer_pages(), 0u);
@@ -70,7 +70,7 @@
     uint32_t num_pages = 128;
     protos::gen::PerfEventConfig cfg;
     cfg.set_ring_buffer_pages(num_pages);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     ASSERT_EQ(event_config->ring_buffer_pages(), num_pages);
@@ -78,7 +78,7 @@
   {  // entire config rejected if not a power of two of pages
     protos::gen::PerfEventConfig cfg;
     cfg.set_ring_buffer_pages(7);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_FALSE(event_config.has_value());
   }
@@ -87,7 +87,7 @@
 TEST(EventConfigTest, ReadTickPeriodDefaultedIfUnset) {
   {  // if unset, a default is used
     protos::gen::PerfEventConfig cfg;
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     ASSERT_GT(event_config->read_tick_period_ms(), 0u);
@@ -96,7 +96,7 @@
     uint32_t period_ms = 250;
     protos::gen::PerfEventConfig cfg;
     cfg.set_ring_buffer_read_period_ms(period_ms);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     ASSERT_EQ(event_config->read_tick_period_ms(), period_ms);
@@ -106,7 +106,7 @@
 TEST(EventConfigTest, RemotePeriodTimeoutDefaultedIfUnset) {
   {  // if unset, a default is used
     protos::gen::PerfEventConfig cfg;
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     ASSERT_GT(event_config->remote_descriptor_timeout_ms(), 0u);
@@ -115,7 +115,7 @@
     uint32_t timeout_ms = 300;
     protos::gen::PerfEventConfig cfg;
     cfg.set_remote_descriptor_timeout_ms(timeout_ms);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     ASSERT_EQ(event_config->remote_descriptor_timeout_ms(), timeout_ms);
@@ -126,7 +126,7 @@
   {  // period:
     protos::gen::PerfEventConfig cfg;
     cfg.mutable_timebase()->set_period(100);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_FALSE(event_config->perf_attr()->freq);
@@ -135,7 +135,7 @@
   {  // frequency:
     protos::gen::PerfEventConfig cfg;
     cfg.mutable_timebase()->set_frequency(4000);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_TRUE(event_config->perf_attr()->freq);
@@ -144,7 +144,7 @@
   {  // legacy frequency field:
     protos::gen::PerfEventConfig cfg;
     cfg.set_sampling_frequency(5000);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_TRUE(event_config->perf_attr()->freq);
@@ -152,7 +152,7 @@
   }
   {  // default is 10 Hz (implementation-defined)
     protos::gen::PerfEventConfig cfg;
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_TRUE(event_config->perf_attr()->freq);
@@ -171,8 +171,7 @@
         cfg.mutable_timebase()->mutable_tracepoint();
     mutable_tracepoint->set_name("sched:sched_switch");
 
-    base::Optional<EventConfig> event_config =
-        CreateEventConfig(cfg, id_lookup);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg, id_lookup);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_EQ(event_config->perf_attr()->type, PERF_TYPE_TRACEPOINT);
@@ -181,7 +180,7 @@
   {  // default is the CPU timer:
     protos::gen::PerfEventConfig cfg;
     cfg.mutable_timebase()->set_frequency(1000);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_EQ(event_config->perf_attr()->type, PERF_TYPE_SOFTWARE);
@@ -199,7 +198,7 @@
     mutable_scope->set_additional_cmdline_count(3);
     mutable_scope->add_exclude_cmdline("heapprofd");
 
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     const auto& filter = event_config->filter();
@@ -220,7 +219,7 @@
     cfg.set_additional_cmdline_count(3);
     cfg.add_exclude_cmdline("heapprofd");
 
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     const auto& filter = event_config->filter();
@@ -241,7 +240,7 @@
     mutable_timebase->set_period(500);
     mutable_timebase->set_counter(protos::gen::PerfEvents::HW_CPU_CYCLES);
 
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_EQ(event_config->perf_attr()->type, PERF_TYPE_HARDWARE);
@@ -256,7 +255,7 @@
     mutable_timebase->set_period(500);
     mutable_timebase->set_counter(protos::gen::PerfEvents::SW_PAGE_FAULTS);
 
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_EQ(event_config->perf_attr()->type, PERF_TYPE_SOFTWARE);
@@ -272,7 +271,7 @@
     protos::gen::PerfEventConfig cfg;
     cfg.mutable_callstack_sampling();  // set field
 
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_TRUE(event_config->sample_callstacks());
@@ -292,7 +291,7 @@
     cfg.mutable_callstack_sampling()->set_user_frames(
         protos::gen::PerfEventConfig::UNWIND_SKIP);
 
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_TRUE(event_config->sample_callstacks());
@@ -315,7 +314,7 @@
   {
     protos::gen::PerfEventConfig cfg;
     cfg.mutable_callstack_sampling()->set_kernel_frames(true);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_TRUE(event_config->kernel_frames());
@@ -324,14 +323,14 @@
     protos::gen::PerfEventConfig cfg;
     cfg.set_all_cpus(true);  // used to detect compat mode
     cfg.set_kernel_frames(true);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_TRUE(event_config->kernel_frames());
   }
   {  // default is false
     protos::gen::PerfEventConfig cfg;
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_FALSE(event_config->kernel_frames());
@@ -341,7 +340,7 @@
 TEST(EventConfigTest, TimestampClockId) {
   {  // if unset, a default is used
     protos::gen::PerfEventConfig cfg;
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_TRUE(event_config->perf_attr()->use_clockid);
@@ -351,7 +350,7 @@
     protos::gen::PerfEventConfig cfg;
     cfg.mutable_timebase()->set_timestamp_clock(
         protos::gen::PerfEvents::PERF_CLOCK_BOOTTIME);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_TRUE(event_config->perf_attr()->use_clockid);
@@ -361,7 +360,7 @@
     protos::gen::PerfEventConfig cfg;
     cfg.mutable_timebase()->set_timestamp_clock(
         protos::gen::PerfEvents::PERF_CLOCK_MONOTONIC);
-    base::Optional<EventConfig> event_config = CreateEventConfig(cfg);
+    std::optional<EventConfig> event_config = CreateEventConfig(cfg);
 
     ASSERT_TRUE(event_config.has_value());
     EXPECT_TRUE(event_config->perf_attr()->use_clockid);
diff --git a/src/profiling/perf/event_reader.cc b/src/profiling/perf/event_reader.cc
index ae6e187..2a40c6c 100644
--- a/src/profiling/perf/event_reader.cc
+++ b/src/profiling/perf/event_reader.cc
@@ -111,9 +111,8 @@
     PERFETTO_PLOG("failed munmap");
 }
 
-base::Optional<PerfRingBuffer> PerfRingBuffer::Allocate(
-    int perf_fd,
-    size_t data_page_count) {
+std::optional<PerfRingBuffer> PerfRingBuffer::Allocate(int perf_fd,
+                                                       size_t data_page_count) {
   // perf_event_open requires the ring buffer to be a power of two in size.
   PERFETTO_DCHECK(IsPowerOfTwo(data_page_count));
 
@@ -128,7 +127,7 @@
                          MAP_SHARED, perf_fd, 0);
   if (mmap_addr == MAP_FAILED) {
     PERFETTO_PLOG("failed mmap");
-    return base::nullopt;
+    return std::nullopt;
   }
 
   // Expected layout is [ metadata page ] [ data pages ... ]
@@ -139,7 +138,7 @@
 
   PERFETTO_DCHECK(IsPowerOfTwo(ret.data_buf_sz_));
 
-  return base::make_optional(std::move(ret));
+  return std::make_optional(std::move(ret));
 }
 
 // See |perf_output_put_handle| for the necessary synchronization between the
@@ -224,39 +223,39 @@
   return *this;
 }
 
-base::Optional<EventReader> EventReader::ConfigureEvents(
+std::optional<EventReader> EventReader::ConfigureEvents(
     uint32_t cpu,
     const EventConfig& event_cfg) {
   auto leader_fd = PerfEventOpen(cpu, event_cfg.perf_attr());
   if (!leader_fd) {
     PERFETTO_PLOG("Failed perf_event_open");
-    return base::nullopt;
+    return std::nullopt;
   }
   if (!MaybeApplyTracepointFilter(leader_fd.get(), event_cfg.timebase_event()))
-    return base::nullopt;
+    return std::nullopt;
 
   auto ring_buffer =
       PerfRingBuffer::Allocate(leader_fd.get(), event_cfg.ring_buffer_pages());
   if (!ring_buffer.has_value()) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return EventReader(cpu, *event_cfg.perf_attr(), std::move(leader_fd),
                      std::move(ring_buffer.value()));
 }
 
-base::Optional<ParsedSample> EventReader::ReadUntilSample(
+std::optional<ParsedSample> EventReader::ReadUntilSample(
     std::function<void(uint64_t)> records_lost_callback) {
   for (;;) {
     char* event = ring_buffer_.ReadRecordNonconsuming();
     if (!event)
-      return base::nullopt;  // caught up with the writer
+      return std::nullopt;  // caught up with the writer
 
     auto* event_hdr = reinterpret_cast<const perf_event_header*>(event);
 
     if (event_hdr->type == PERF_RECORD_SAMPLE) {
       ParsedSample sample = ParseSampleRecord(cpu_, event);
       ring_buffer_.Consume(event_hdr->size);
-      return base::make_optional(std::move(sample));
+      return std::make_optional(std::move(sample));
     }
 
     if (event_hdr->type == PERF_RECORD_LOST) {
diff --git a/src/profiling/perf/event_reader.h b/src/profiling/perf/event_reader.h
index 92e7521..11a63bb 100644
--- a/src/profiling/perf/event_reader.h
+++ b/src/profiling/perf/event_reader.h
@@ -21,8 +21,8 @@
 #include <stdint.h>
 #include <sys/mman.h>
 #include <sys/types.h>
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/tracing/core/basic_types.h"
 #include "src/profiling/perf/common_types.h"
@@ -33,8 +33,8 @@
 
 class PerfRingBuffer {
  public:
-  static base::Optional<PerfRingBuffer> Allocate(int perf_fd,
-                                                 size_t data_page_count);
+  static std::optional<PerfRingBuffer> Allocate(int perf_fd,
+                                                size_t data_page_count);
 
   ~PerfRingBuffer();
 
@@ -71,14 +71,14 @@
 
 class EventReader {
  public:
-  static base::Optional<EventReader> ConfigureEvents(
+  static std::optional<EventReader> ConfigureEvents(
       uint32_t cpu,
       const EventConfig& event_cfg);
 
   // Consumes records from the ring buffer until either encountering a sample,
   // or catching up to the writer. The other record of interest
   // (PERF_RECORD_LOST) is handled via the given callback.
-  base::Optional<ParsedSample> ReadUntilSample(
+  std::optional<ParsedSample> ReadUntilSample(
       std::function<void(uint64_t)> lost_events_callback);
 
   void EnableEvents();
diff --git a/src/profiling/perf/perf_producer.cc b/src/profiling/perf/perf_producer.cc
index ee15555..0fb7be3 100644
--- a/src/profiling/perf/perf_producer.cc
+++ b/src/profiling/perf/perf_producer.cc
@@ -379,7 +379,7 @@
   // Unlikely: handle a callstack sampling option that shares a random decision
   // between all data sources within a tracing session. Instead of introducing
   // session-scoped data, we replicate the decision in each per-DS EventConfig.
-  base::Optional<ProcessSharding> process_sharding;
+  std::optional<ProcessSharding> process_sharding;
   uint32_t shard_count =
       event_config_pb.callstack_sampling().scope().process_shard_count();
   if (shard_count > 0) {
@@ -387,7 +387,7 @@
         GetOrChooseCallstackProcessShard(tracing_session_id, shard_count);
   }
 
-  base::Optional<EventConfig> event_config = EventConfig::Create(
+  std::optional<EventConfig> event_config = EventConfig::Create(
       event_config_pb, config, process_sharding, tracepoint_id_lookup);
   if (!event_config.has_value()) {
     PERFETTO_ELOG("PerfEventConfig rejected.");
@@ -397,7 +397,7 @@
   size_t num_cpus = NumberOfCpus();
   std::vector<EventReader> per_cpu_readers;
   for (uint32_t cpu = 0; cpu < num_cpus; cpu++) {
-    base::Optional<EventReader> event_reader =
+    std::optional<EventReader> event_reader =
         EventReader::ConfigureEvents(cpu, event_config.value());
     if (!event_reader.has_value()) {
       PERFETTO_ELOG("Failed to set up perf events for cpu%" PRIu32
@@ -632,7 +632,7 @@
   };
 
   for (uint64_t i = 0; i < max_samples; i++) {
-    base::Optional<ParsedSample> sample =
+    std::optional<ParsedSample> sample =
         reader->ReadUntilSample(records_lost_callback);
     if (!sample) {
       return false;  // caught up to the writer
@@ -1082,7 +1082,7 @@
 // * reuse a choice made previously by a data source within this tracing
 //   session. The config option requires that all data sources within one config
 //   have the same shard count.
-base::Optional<ProcessSharding> PerfProducer::GetOrChooseCallstackProcessShard(
+std::optional<ProcessSharding> PerfProducer::GetOrChooseCallstackProcessShard(
     uint64_t tracing_session_id,
     uint32_t shard_count) {
   for (auto& it : data_sources_) {
diff --git a/src/profiling/perf/perf_producer.h b/src/profiling/perf/perf_producer.h
index 31d5ff5..83174d3 100644
--- a/src/profiling/perf/perf_producer.h
+++ b/src/profiling/perf/perf_producer.h
@@ -17,16 +17,15 @@
 #ifndef SRC_PROFILING_PERF_PERF_PRODUCER_H_
 #define SRC_PROFILING_PERF_PERF_PRODUCER_H_
 
+#include <unistd.h>
 #include <map>
 #include <memory>
-
-#include <unistd.h>
+#include <optional>
 
 #include <unwindstack/Error.h>
 #include <unwindstack/Regs.h>
 
 #include "perfetto/base/task_runner.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/unix_socket.h"
 #include "perfetto/ext/base/weak_ptr.h"
@@ -240,7 +239,7 @@
 
   // Chooses a random parameter for a callstack sampling option. Done at this
   // level as the choice is shared by all data sources within a tracing session.
-  base::Optional<ProcessSharding> GetOrChooseCallstackProcessShard(
+  std::optional<ProcessSharding> GetOrChooseCallstackProcessShard(
       uint64_t tracing_session_id,
       uint32_t shard_count);
 
diff --git a/src/profiling/perf/perf_producer_unittest.cc b/src/profiling/perf/perf_producer_unittest.cc
index 22f4002..76b615a 100644
--- a/src/profiling/perf/perf_producer_unittest.cc
+++ b/src/profiling/perf/perf_producer_unittest.cc
@@ -17,9 +17,9 @@
 #include "src/profiling/perf/perf_producer.h"
 
 #include <stdint.h>
+#include <optional>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "test/gtest_and_gmock.h"
 
 namespace perfetto {
diff --git a/src/profiling/perf/unwinding.h b/src/profiling/perf/unwinding.h
index 08d6e86..8295fb8 100644
--- a/src/profiling/perf/unwinding.h
+++ b/src/profiling/perf/unwinding.h
@@ -17,18 +17,17 @@
 #ifndef SRC_PROFILING_PERF_UNWINDING_H_
 #define SRC_PROFILING_PERF_UNWINDING_H_
 
+#include <stdint.h>
 #include <condition_variable>
 #include <map>
+#include <optional>
 #include <thread>
 
 #include <linux/perf_event.h>
-#include <stdint.h>
-
 #include <unwindstack/Error.h>
 
 #include "perfetto/base/flat_set.h"
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/thread_checker.h"
 #include "perfetto/ext/base/unix_task_runner.h"
 #include "perfetto/ext/tracing/core/basic_types.h"
@@ -137,7 +136,7 @@
 
     Status status = Status::kInitial;
     // Present iff status == kFdsResolved.
-    base::Optional<UnwindingMetadata> unwind_state;
+    std::optional<UnwindingMetadata> unwind_state;
     // Used to distinguish first-time unwinding attempts for a process, for
     // logging purposes.
     bool attempted_unwinding = false;
diff --git a/src/profiling/symbolizer/breakpad_parser.cc b/src/profiling/symbolizer/breakpad_parser.cc
index 5c3c5c0..5e996a7 100644
--- a/src/profiling/symbolizer/breakpad_parser.cc
+++ b/src/profiling/symbolizer/breakpad_parser.cc
@@ -32,18 +32,18 @@
   return i < sym.start_address;
 }
 
-base::Optional<std::string> GetFileContents(const std::string& file_path) {
+std::optional<std::string> GetFileContents(const std::string& file_path) {
   std::string file_contents;
   base::ScopedFile fd = base::OpenFile(file_path, O_RDONLY);
   // Read the contents of the file into |file_contents|.
   if (!fd) {
-    return base::nullopt;
+    return std::nullopt;
   }
   if (!base::ReadFileDescriptor(fd.get(), &file_contents)) {
-    return base::nullopt;
+    return std::nullopt;
   }
 
-  return base::make_optional(std::move(file_contents));
+  return std::make_optional(std::move(file_contents));
 }
 
 // Parses the given string and determines if it begins with the label
@@ -65,7 +65,7 @@
     : file_path_(file_path) {}
 
 bool BreakpadParser::ParseFile() {
-  base::Optional<std::string> file_contents = GetFileContents(file_path_);
+  std::optional<std::string> file_contents = GetFileContents(file_path_);
   if (!file_contents) {
     PERFETTO_ELOG("Could not get file contents of %s.", file_path_.c_str());
     return false;
@@ -111,7 +111,7 @@
   return true;
 }
 
-base::Optional<std::string> BreakpadParser::GetSymbol(uint64_t address) const {
+std::optional<std::string> BreakpadParser::GetSymbol(uint64_t address) const {
   // Returns an iterator pointing to the first element where the symbol's start
   // address is greater than |address|.
   auto it = std::upper_bound(symbols_.begin(), symbols_.end(), address,
@@ -119,7 +119,7 @@
   // If the first symbol's address is greater than |address| then |address| is
   // too low to appear in |symbols_|.
   if (it == symbols_.begin()) {
-    return base::nullopt;
+    return std::nullopt;
   }
   // upper_bound() returns the first symbol who's start address is greater than
   // |address|. Therefore to find the symbol with a range of addresses that
@@ -130,7 +130,7 @@
       address < it->start_address + it->function_size) {
     return it->symbol_name;
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 base::Status BreakpadParser::ParseIfFuncRecord(base::StringView current_line) {
@@ -170,7 +170,7 @@
   }
 
   // Get the start address.
-  base::Optional<uint64_t> optional_address =
+  std::optional<uint64_t> optional_address =
       base::CStringToUInt64(words.cur_token(), 16);
   if (!optional_address) {
     return base::Status("Address should be hexadecimal.");
@@ -179,7 +179,7 @@
 
   // Get the function size.
   words.Next();
-  base::Optional<size_t> optional_func_size =
+  std::optional<size_t> optional_func_size =
       base::CStringToUInt32(words.cur_token(), 16);
   if (!optional_func_size) {
     return base::Status("Function size should be hexadecimal.");
diff --git a/src/profiling/symbolizer/breakpad_parser.h b/src/profiling/symbolizer/breakpad_parser.h
index 0377353..8926a94 100644
--- a/src/profiling/symbolizer/breakpad_parser.h
+++ b/src/profiling/symbolizer/breakpad_parser.h
@@ -17,11 +17,11 @@
 #ifndef SRC_PROFILING_SYMBOLIZER_BREAKPAD_PARSER_H_
 #define SRC_PROFILING_SYMBOLIZER_BREAKPAD_PARSER_H_
 
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 
 namespace perfetto {
@@ -64,7 +64,7 @@
   // Returns the function name corresponding to |address| as a string. The
   // search is log(N) on the number of functions in the binary. |address| is the
   // relative offset from the start of the binary.
-  base::Optional<std::string> GetSymbol(uint64_t address) const;
+  std::optional<std::string> GetSymbol(uint64_t address) const;
 
   const std::vector<Symbol>& symbols_for_testing() const { return symbols_; }
 
diff --git a/src/profiling/symbolizer/breakpad_symbolizer.cc b/src/profiling/symbolizer/breakpad_symbolizer.cc
index c7558c7..763d34f 100644
--- a/src/profiling/symbolizer/breakpad_symbolizer.cc
+++ b/src/profiling/symbolizer/breakpad_symbolizer.cc
@@ -16,9 +16,10 @@
 
 #include "src/profiling/symbolizer/breakpad_symbolizer.h"
 
+#include <optional>
+
 #include "perfetto/base/build_config.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/ext/base/string_writer.h"
 #include "src/profiling/symbolizer/breakpad_parser.h"
@@ -83,7 +84,7 @@
   // Add each address's function name to the |result| vector in the same order.
   for (uint64_t addr : address) {
     SymbolizedFrame frame;
-    base::Optional<std::string> opt_func_name = parser.GetSymbol(addr);
+    std::optional<std::string> opt_func_name = parser.GetSymbol(addr);
     if (opt_func_name) {
       frame.function_name = *opt_func_name;
       num_symbolized_frames++;
diff --git a/src/profiling/symbolizer/local_symbolizer.cc b/src/profiling/symbolizer/local_symbolizer.cc
index ce11a40..0382556 100644
--- a/src/profiling/symbolizer/local_symbolizer.cc
+++ b/src/profiling/symbolizer/local_symbolizer.cc
@@ -20,6 +20,7 @@
 
 #include <cinttypes>
 #include <memory>
+#include <optional>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -28,7 +29,6 @@
 #include "perfetto/base/compiler.h"
 #include "perfetto/base/logging.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "src/profiling/symbolizer/elf.h"
@@ -126,17 +126,17 @@
 }
 
 template <typename E>
-base::Optional<uint64_t> GetLoadBias(void* mem, size_t size) {
+std::optional<uint64_t> GetLoadBias(void* mem, size_t size) {
   const typename E::Ehdr* ehdr = static_cast<typename E::Ehdr*>(mem);
   if (!InRange(mem, size, ehdr, sizeof(typename E::Ehdr))) {
     PERFETTO_ELOG("Corrupted ELF.");
-    return base::nullopt;
+    return std::nullopt;
   }
   for (size_t i = 0; i < ehdr->e_phnum; ++i) {
     typename E::Phdr* phdr = GetPhdr<E>(mem, ehdr, i);
     if (!InRange(mem, size, phdr, sizeof(typename E::Phdr))) {
       PERFETTO_ELOG("Corrupted ELF.");
-      return base::nullopt;
+      return std::nullopt;
     }
     if (phdr->p_type == PT_LOAD && phdr->p_flags & PF_X) {
       return phdr->p_vaddr - phdr->p_offset;
@@ -146,17 +146,17 @@
 }
 
 template <typename E>
-base::Optional<std::string> GetBuildId(void* mem, size_t size) {
+std::optional<std::string> GetBuildId(void* mem, size_t size) {
   const typename E::Ehdr* ehdr = static_cast<typename E::Ehdr*>(mem);
   if (!InRange(mem, size, ehdr, sizeof(typename E::Ehdr))) {
     PERFETTO_ELOG("Corrupted ELF.");
-    return base::nullopt;
+    return std::nullopt;
   }
   for (size_t i = 0; i < ehdr->e_shnum; ++i) {
     typename E::Shdr* shdr = GetShdr<E>(mem, ehdr, i);
     if (!InRange(mem, size, shdr, sizeof(typename E::Shdr))) {
       PERFETTO_ELOG("Corrupted ELF.");
-      return base::nullopt;
+      return std::nullopt;
     }
 
     if (shdr->sh_type != SHT_NOTE)
@@ -169,13 +169,13 @@
 
       if (!InRange(mem, size, nhdr, sizeof(typename E::Nhdr))) {
         PERFETTO_ELOG("Corrupted ELF.");
-        return base::nullopt;
+        return std::nullopt;
       }
       if (nhdr->n_type == NT_GNU_BUILD_ID && nhdr->n_namesz == 4) {
         char* name = reinterpret_cast<char*>(nhdr) + sizeof(*nhdr);
         if (!InRange(mem, size, name, 4)) {
           PERFETTO_ELOG("Corrupted ELF.");
-          return base::nullopt;
+          return std::nullopt;
         }
         if (memcmp(name, "GNU", 3) == 0) {
           const char* value = reinterpret_cast<char*>(nhdr) + sizeof(*nhdr) +
@@ -183,7 +183,7 @@
 
           if (!InRange(mem, size, value, nhdr->n_descsz)) {
             PERFETTO_ELOG("Corrupted ELF.");
-            return base::nullopt;
+            return std::nullopt;
           }
           return std::string(value, nhdr->n_descsz);
         }
@@ -192,7 +192,7 @@
                 base::AlignUp<4>(nhdr->n_descsz);
     }
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 std::string SplitBuildID(const std::string& hex_build_id) {
@@ -217,23 +217,23 @@
   uint64_t load_bias;
 };
 
-base::Optional<BuildIdAndLoadBias> GetBuildIdAndLoadBias(const char* fname,
-                                                         size_t size) {
+std::optional<BuildIdAndLoadBias> GetBuildIdAndLoadBias(const char* fname,
+                                                        size_t size) {
   static_assert(EI_CLASS > EI_MAG3, "mem[EI_MAG?] accesses are in range.");
   if (size <= EI_CLASS)
-    return base::nullopt;
+    return std::nullopt;
   ScopedReadMmap map(fname, size);
   if (!map.IsValid()) {
     PERFETTO_PLOG("mmap");
-    return base::nullopt;
+    return std::nullopt;
   }
   char* mem = static_cast<char*>(*map);
 
   if (!IsElf(mem, size))
-    return base::nullopt;
+    return std::nullopt;
 
-  base::Optional<std::string> build_id;
-  base::Optional<uint64_t> load_bias;
+  std::optional<std::string> build_id;
+  std::optional<uint64_t> load_bias;
   switch (mem[EI_CLASS]) {
     case ELFCLASS32:
       build_id = GetBuildId<Elf32>(mem, size);
@@ -244,12 +244,12 @@
       load_bias = GetLoadBias<Elf64>(mem, size);
       break;
     default:
-      return base::nullopt;
+      return std::nullopt;
   }
   if (build_id && load_bias) {
     return BuildIdAndLoadBias{*build_id, *load_bias};
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 std::map<std::string, FoundBinary> BuildIdIndex(std::vector<std::string> dirs) {
@@ -274,7 +274,7 @@
         return;
       }
     }
-    base::Optional<BuildIdAndLoadBias> build_id_and_load_bias =
+    std::optional<BuildIdAndLoadBias> build_id_and_load_bias =
         GetBuildIdAndLoadBias(fname, size);
     if (build_id_and_load_bias) {
       result.emplace(build_id_and_load_bias->build_id,
@@ -298,7 +298,7 @@
   *file_name = line.substr(0, row_pos);
   auto line_no_str = line.substr(row_pos + 1, col_pos - row_pos - 1);
 
-  base::Optional<int32_t> opt_parsed_line_no = base::StringToInt32(line_no_str);
+  std::optional<int32_t> opt_parsed_line_no = base::StringToInt32(line_no_str);
   if (!opt_parsed_line_no || *opt_parsed_line_no < 0)
     return false;
   *line_no = static_cast<uint32_t>(*opt_parsed_line_no);
@@ -310,7 +310,7 @@
 LocalBinaryIndexer::LocalBinaryIndexer(std::vector<std::string> roots)
     : buildid_to_file_(BuildIdIndex(std::move(roots))) {}
 
-base::Optional<FoundBinary> LocalBinaryIndexer::FindBinary(
+std::optional<FoundBinary> LocalBinaryIndexer::FindBinary(
     const std::string& abspath,
     const std::string& build_id) {
   auto it = buildid_to_file_.find(build_id);
@@ -318,7 +318,7 @@
     return it->second;
   PERFETTO_ELOG("Could not find Build ID: %s (file %s).",
                 base::ToHex(build_id).c_str(), abspath.c_str());
-  return base::nullopt;
+  return std::nullopt;
 }
 
 LocalBinaryIndexer::~LocalBinaryIndexer() = default;
@@ -326,14 +326,14 @@
 LocalBinaryFinder::LocalBinaryFinder(std::vector<std::string> roots)
     : roots_(std::move(roots)) {}
 
-base::Optional<FoundBinary> LocalBinaryFinder::FindBinary(
+std::optional<FoundBinary> LocalBinaryFinder::FindBinary(
     const std::string& abspath,
     const std::string& build_id) {
-  auto p = cache_.emplace(abspath, base::nullopt);
+  auto p = cache_.emplace(abspath, std::nullopt);
   if (!p.second)
     return p.first->second;
 
-  base::Optional<FoundBinary>& cache_entry = p.first->second;
+  std::optional<FoundBinary>& cache_entry = p.first->second;
 
   for (const std::string& root_str : roots_) {
     cache_entry = FindBinaryInRoot(root_str, abspath, build_id);
@@ -345,30 +345,30 @@
   return cache_entry;
 }
 
-base::Optional<FoundBinary> LocalBinaryFinder::IsCorrectFile(
+std::optional<FoundBinary> LocalBinaryFinder::IsCorrectFile(
     const std::string& symbol_file,
     const std::string& build_id) {
   if (!base::FileExists(symbol_file)) {
-    return base::nullopt;
+    return std::nullopt;
   }
   // Openfile opens the file with an exclusive lock on windows.
   size_t size = GetFileSize(symbol_file);
 
   if (size == 0) {
-    return base::nullopt;
+    return std::nullopt;
   }
 
-  base::Optional<BuildIdAndLoadBias> build_id_and_load_bias =
+  std::optional<BuildIdAndLoadBias> build_id_and_load_bias =
       GetBuildIdAndLoadBias(symbol_file.c_str(), size);
   if (!build_id_and_load_bias)
-    return base::nullopt;
+    return std::nullopt;
   if (build_id_and_load_bias->build_id != build_id) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return FoundBinary{symbol_file, build_id_and_load_bias->load_bias};
 }
 
-base::Optional<FoundBinary> LocalBinaryFinder::FindBinaryInRoot(
+std::optional<FoundBinary> LocalBinaryFinder::FindBinaryInRoot(
     const std::string& root_str,
     const std::string& abspath,
     const std::string& build_id) {
@@ -404,7 +404,7 @@
   // * $ROOT/foo.so
   // * $ROOT/.build-id/ab/cd1234.debug
 
-  base::Optional<FoundBinary> result;
+  std::optional<FoundBinary> result;
 
   std::string symbol_file = root_str + "/" + dirname + "/" + filename;
   result = IsCorrectFile(symbol_file, build_id);
@@ -446,7 +446,7 @@
     }
   }
 
-  return base::nullopt;
+  return std::nullopt;
 }
 
 LocalBinaryFinder::~LocalBinaryFinder() = default;
@@ -507,7 +507,7 @@
     const std::string& build_id,
     uint64_t load_bias,
     const std::vector<uint64_t>& addresses) {
-  base::Optional<FoundBinary> binary =
+  std::optional<FoundBinary> binary =
       finder_->FindBinary(mapping_name, build_id);
   if (!binary)
     return {};
diff --git a/src/profiling/symbolizer/local_symbolizer.h b/src/profiling/symbolizer/local_symbolizer.h
index bb8b0c2..f92c553 100644
--- a/src/profiling/symbolizer/local_symbolizer.h
+++ b/src/profiling/symbolizer/local_symbolizer.h
@@ -17,12 +17,13 @@
 #ifndef SRC_PROFILING_SYMBOLIZER_LOCAL_SYMBOLIZER_H_
 #define SRC_PROFILING_SYMBOLIZER_LOCAL_SYMBOLIZER_H_
 
+#include <functional>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "src/profiling/symbolizer/subprocess.h"
 #include "src/profiling/symbolizer/symbolizer.h"
@@ -44,7 +45,7 @@
 class BinaryFinder {
  public:
   virtual ~BinaryFinder();
-  virtual base::Optional<FoundBinary> FindBinary(
+  virtual std::optional<FoundBinary> FindBinary(
       const std::string& abspath,
       const std::string& build_id) = 0;
 };
@@ -53,8 +54,8 @@
  public:
   explicit LocalBinaryIndexer(std::vector<std::string> roots);
 
-  base::Optional<FoundBinary> FindBinary(const std::string& abspath,
-                                         const std::string& build_id) override;
+  std::optional<FoundBinary> FindBinary(const std::string& abspath,
+                                        const std::string& build_id) override;
   ~LocalBinaryIndexer() override;
 
  private:
@@ -65,22 +66,22 @@
  public:
   explicit LocalBinaryFinder(std::vector<std::string> roots);
 
-  base::Optional<FoundBinary> FindBinary(const std::string& abspath,
-                                         const std::string& build_id) override;
+  std::optional<FoundBinary> FindBinary(const std::string& abspath,
+                                        const std::string& build_id) override;
 
   ~LocalBinaryFinder() override;
 
  private:
-  base::Optional<FoundBinary> IsCorrectFile(const std::string& symbol_file,
-                                            const std::string& build_id);
+  std::optional<FoundBinary> IsCorrectFile(const std::string& symbol_file,
+                                           const std::string& build_id);
 
-  base::Optional<FoundBinary> FindBinaryInRoot(const std::string& root_str,
-                                               const std::string& abspath,
-                                               const std::string& build_id);
+  std::optional<FoundBinary> FindBinaryInRoot(const std::string& root_str,
+                                              const std::string& abspath,
+                                              const std::string& build_id);
 
  private:
   std::vector<std::string> roots_;
-  std::map<std::string, base::Optional<FoundBinary>> cache_;
+  std::map<std::string, std::optional<FoundBinary>> cache_;
 };
 
 class LLVMSymbolizerProcess {
diff --git a/src/profiling/symbolizer/local_symbolizer_unittest.cc b/src/profiling/symbolizer/local_symbolizer_unittest.cc
index 919e3ff..04d4855 100644
--- a/src/profiling/symbolizer/local_symbolizer_unittest.cc
+++ b/src/profiling/symbolizer/local_symbolizer_unittest.cc
@@ -163,7 +163,7 @@
 
   LocalBinaryIndexer indexer({tmp.path() + "/dir1", tmp.path() + "/dir2"});
 
-  base::Optional<FoundBinary> bin1 =
+  std::optional<FoundBinary> bin1 =
       indexer.FindBinary("", "AAAAAAAAAAAAAAAAAAAA");
   ASSERT_TRUE(bin1.has_value());
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
@@ -171,7 +171,7 @@
 #else
   EXPECT_EQ(bin1.value().file_name, tmp.path() + "/dir1/elf1");
 #endif
-  base::Optional<FoundBinary> bin2 =
+  std::optional<FoundBinary> bin2 =
       indexer.FindBinary("", "BBBBBBBBBBBBBBBBBBBB");
   ASSERT_TRUE(bin2.has_value());
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
@@ -208,17 +208,17 @@
 
   LocalBinaryIndexer indexer({tmp.AbsolutePath("sym")});
 
-  base::Optional<FoundBinary> bin1 =
+  std::optional<FoundBinary> bin1 =
       indexer.FindBinary("", "AAAAAAAAAAAAAAAAAAAA");
   ASSERT_TRUE(bin1.has_value());
   EXPECT_EQ(bin1.value().file_name, tmp.AbsolutePath("sym/elf1"));
 
-  base::Optional<FoundBinary> bin2 =
+  std::optional<FoundBinary> bin2 =
       indexer.FindBinary("", "BBBBBBBBBBBBBBBBBBBB");
   ASSERT_TRUE(bin2.has_value());
   EXPECT_EQ(bin2.value().file_name, tmp.AbsolutePath("sym/dir1/elf2"));
 
-  base::Optional<FoundBinary> bin3 =
+  std::optional<FoundBinary> bin3 =
       indexer.FindBinary("", "CCCCCCCCCCCCCCCCCCCC");
   ASSERT_TRUE(bin3.has_value());
   EXPECT_EQ(bin3.value().file_name, tmp.AbsolutePath("sym/dir1/elf3"));
@@ -241,7 +241,7 @@
 
   LocalBinaryIndexer indexer({tmp.AbsolutePath("main")});
 
-  base::Optional<FoundBinary> bin1 =
+  std::optional<FoundBinary> bin1 =
       indexer.FindBinary("", "AAAAAAAAAAAAAAAAAAAA");
   ASSERT_TRUE(bin1.has_value());
   EXPECT_EQ(bin1.value().file_name, tmp.AbsolutePath("main/elf1"));
@@ -259,7 +259,7 @@
 
   LocalBinaryFinder finder({tmp.path() + "/root"});
 
-  base::Optional<FoundBinary> bin1 =
+  std::optional<FoundBinary> bin1 =
       finder.FindBinary("/dir/elf1.so", "AAAAAAAAAAAAAAAAAAAA");
   ASSERT_TRUE(bin1.has_value());
   EXPECT_EQ(bin1.value().file_name, tmp.path() + "/root/dir/elf1.so");
@@ -273,7 +273,7 @@
 
   LocalBinaryFinder finder({tmp.path() + "/root"});
 
-  base::Optional<FoundBinary> bin1 =
+  std::optional<FoundBinary> bin1 =
       finder.FindBinary("/dir/base.apk!elf1.so", "AAAAAAAAAAAAAAAAAAAA");
   ASSERT_TRUE(bin1.has_value());
   EXPECT_EQ(bin1.value().file_name, tmp.path() + "/root/dir/elf1.so");
@@ -286,7 +286,7 @@
 
   LocalBinaryFinder finder({tmp.path() + "/root"});
 
-  base::Optional<FoundBinary> bin1 =
+  std::optional<FoundBinary> bin1 =
       finder.FindBinary("/ignored_dir/elf1.so", "AAAAAAAAAAAAAAAAAAAA");
   ASSERT_TRUE(bin1.has_value());
   EXPECT_EQ(bin1.value().file_name, tmp.path() + "/root/elf1.so");
@@ -299,7 +299,7 @@
 
   LocalBinaryFinder finder({tmp.path() + "/root"});
 
-  base::Optional<FoundBinary> bin1 = finder.FindBinary(
+  std::optional<FoundBinary> bin1 = finder.FindBinary(
       "/ignored_dir/base.apk!elf1.so", "AAAAAAAAAAAAAAAAAAAA");
   ASSERT_TRUE(bin1.has_value());
   EXPECT_EQ(bin1.value().file_name, tmp.path() + "/root/elf1.so");
@@ -315,7 +315,7 @@
 
   LocalBinaryFinder finder({tmp.path() + "/root"});
 
-  base::Optional<FoundBinary> bin1 =
+  std::optional<FoundBinary> bin1 =
       finder.FindBinary("/ignored_dir/ignored_name.so", "AAAAAAAAAAAAAAAAAAAA");
   ASSERT_TRUE(bin1.has_value());
   EXPECT_EQ(
diff --git a/src/tools/multithreaded_alloc.cc b/src/tools/multithreaded_alloc.cc
index 4c5e603..a4490d9 100644
--- a/src/tools/multithreaded_alloc.cc
+++ b/src/tools/multithreaded_alloc.cc
@@ -23,13 +23,13 @@
 #include <condition_variable>
 #include <iterator>
 #include <mutex>
+#include <optional>
 #include <thread>
 #include <vector>
 
 #include "perfetto/base/logging.h"
 #include "perfetto/base/time.h"
 #include "perfetto/ext/base/getopt.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/heap_profile.h"
 
@@ -87,21 +87,21 @@
     PERFETTO_FATAL("%s NUMBER_THREADS RUNTIME_MS PENDING_ALLOCS", argv[0]);
   }
 
-  perfetto::base::Optional<uint64_t> opt_no_threads =
+  std::optional<uint64_t> opt_no_threads =
       perfetto::base::CStringToUInt64(argv[1]);
   if (!opt_no_threads) {
     PERFETTO_FATAL("Invalid number of threads: %s", argv[1]);
   }
   uint64_t no_threads = *opt_no_threads;
 
-  perfetto::base::Optional<uint64_t> opt_runtime_ms =
+  std::optional<uint64_t> opt_runtime_ms =
       perfetto::base::CStringToUInt64(argv[2]);
   if (!opt_runtime_ms) {
     PERFETTO_FATAL("Invalid runtime: %s", argv[2]);
   }
   uint64_t runtime_ms = *opt_runtime_ms;
 
-  perfetto::base::Optional<uint64_t> opt_pending_allocs =
+  std::optional<uint64_t> opt_pending_allocs =
       perfetto::base::CStringToUInt64(argv[3]);
   if (!opt_runtime_ms) {
     PERFETTO_FATAL("Invalid number of pending allocs: %s", argv[3]);
diff --git a/src/tools/proto_merger/proto_file.cc b/src/tools/proto_merger/proto_file.cc
index 653d271..bf1a715 100644
--- a/src/tools/proto_merger/proto_file.cc
+++ b/src/tools/proto_merger/proto_file.cc
@@ -60,8 +60,8 @@
         "repeated",  // LABEL_REPEATED
 };
 
-base::Optional<std::string> MinimizeType(const std::string& a,
-                                         const std::string& b) {
+std::optional<std::string> MinimizeType(const std::string& a,
+                                        const std::string& b) {
   auto a_pieces = base::SplitString(a, ".");
   auto b_pieces = base::SplitString(b, ".");
 
@@ -71,7 +71,7 @@
       return a.substr(skip);
     skip += a_pieces[i].size() + 1;
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 std::string SimpleFieldTypeFromDescriptor(
diff --git a/src/tools/proto_merger/proto_merger.cc b/src/tools/proto_merger/proto_merger.cc
index 6bd30ce..ba7a701 100644
--- a/src/tools/proto_merger/proto_merger.cc
+++ b/src/tools/proto_merger/proto_merger.cc
@@ -16,19 +16,20 @@
 
 #include "src/tools/proto_merger/proto_merger.h"
 
+#include <optional>
+
 #include "perfetto/base/logging.h"
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 
 namespace perfetto {
 namespace proto_merger {
 namespace {
 
 template <typename Key, typename Value>
-base::Optional<Value> FindInMap(const std::map<Key, Value>& map,
-                                const Key& key) {
+std::optional<Value> FindInMap(const std::map<Key, Value>& map,
+                               const Key& key) {
   auto it = map.find(key);
-  return it == map.end() ? base::nullopt : base::make_optional(it->second);
+  return it == map.end() ? std::nullopt : std::make_optional(it->second);
 }
 
 // Finds the given 'name' in the vector by comparing against
diff --git a/src/trace_processor/containers/nullable_vector.h b/src/trace_processor/containers/nullable_vector.h
index 44bb084..0880b12 100644
--- a/src/trace_processor/containers/nullable_vector.h
+++ b/src/trace_processor/containers/nullable_vector.h
@@ -20,9 +20,9 @@
 #include <stdint.h>
 
 #include <deque>
+#include <optional>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/containers/row_map.h"
 
 namespace perfetto {
@@ -67,14 +67,14 @@
   // Creates a dense nullable vector
   static NullableVector<T> Dense() { return NullableVector<T>(Mode::kDense); }
 
-  // Returns the optional value at |idx| or base::nullopt if the value is null.
-  base::Optional<T> Get(uint32_t idx) const {
+  // Returns the optional value at |idx| or std::nullopt if the value is null.
+  std::optional<T> Get(uint32_t idx) const {
     bool contains = valid_.IsSet(idx);
     if (mode_ == Mode::kDense) {
-      return contains ? base::make_optional(data_[idx]) : base::nullopt;
+      return contains ? std::make_optional(data_[idx]) : std::nullopt;
     } else {
-      return contains ? base::make_optional(data_[valid_.CountSetBits(idx)])
-                      : base::nullopt;
+      return contains ? std::make_optional(data_[valid_.CountSetBits(idx)])
+                      : std::nullopt;
     }
   }
 
@@ -85,7 +85,7 @@
   }
 
   // Adds the given optional value to the NullableVector.
-  void Append(base::Optional<T> val) {
+  void Append(std::optional<T> val) {
     if (val) {
       Append(*val);
     } else {
diff --git a/src/trace_processor/containers/nullable_vector_unittest.cc b/src/trace_processor/containers/nullable_vector_unittest.cc
index 471f616..c256ec4 100644
--- a/src/trace_processor/containers/nullable_vector_unittest.cc
+++ b/src/trace_processor/containers/nullable_vector_unittest.cc
@@ -26,23 +26,23 @@
   NullableVector<int64_t> sv;
   sv.Append(10);
   sv.Append(20);
-  sv.Append(base::nullopt);
+  sv.Append(std::nullopt);
   sv.Append(40);
 
   ASSERT_FALSE(sv.IsDense());
   ASSERT_EQ(sv.size(), 4u);
-  ASSERT_EQ(sv.Get(0), base::Optional<int64_t>(10));
-  ASSERT_EQ(sv.Get(1), base::Optional<int64_t>(20));
-  ASSERT_EQ(sv.Get(2), base::nullopt);
-  ASSERT_EQ(sv.Get(3), base::Optional<int64_t>(40));
+  ASSERT_EQ(sv.Get(0), std::optional<int64_t>(10));
+  ASSERT_EQ(sv.Get(1), std::optional<int64_t>(20));
+  ASSERT_EQ(sv.Get(2), std::nullopt);
+  ASSERT_EQ(sv.Get(3), std::optional<int64_t>(40));
 }
 
 TEST(NullableVector, Set) {
   NullableVector<int64_t> sv;
   sv.Append(10);
   sv.Append(20);
-  sv.Append(base::nullopt);
-  sv.Append(base::nullopt);
+  sv.Append(std::nullopt);
+  sv.Append(std::nullopt);
   sv.Append(40);
 
   sv.Set(0, 15);
@@ -50,7 +50,7 @@
 
   ASSERT_EQ(*sv.Get(0), 15);
   ASSERT_EQ(*sv.Get(1), 20);
-  ASSERT_EQ(sv.Get(2), base::nullopt);
+  ASSERT_EQ(sv.Get(2), std::nullopt);
   ASSERT_EQ(*sv.Get(3), 30);
   ASSERT_EQ(*sv.Get(4), 40);
 }
@@ -64,27 +64,27 @@
 
   sv.Set(1, 22);
 
-  ASSERT_EQ(sv.Get(0), base::Optional<int64_t>(1));
-  ASSERT_EQ(sv.Get(1), base::Optional<int64_t>(22));
-  ASSERT_EQ(sv.Get(2), base::Optional<int64_t>(3));
-  ASSERT_EQ(sv.Get(3), base::Optional<int64_t>(4));
+  ASSERT_EQ(sv.Get(0), std::optional<int64_t>(1));
+  ASSERT_EQ(sv.Get(1), std::optional<int64_t>(22));
+  ASSERT_EQ(sv.Get(2), std::optional<int64_t>(3));
+  ASSERT_EQ(sv.Get(3), std::optional<int64_t>(4));
 }
 
 TEST(NullableVector, Dense) {
   auto sv = NullableVector<int64_t>::Dense();
 
   sv.Append(0);
-  sv.Append(base::nullopt);
+  sv.Append(std::nullopt);
   sv.Append(2);
   sv.Append(3);
-  sv.Append(base::nullopt);
+  sv.Append(std::nullopt);
 
   ASSERT_TRUE(sv.IsDense());
   ASSERT_EQ(sv.Get(0), 0);
-  ASSERT_EQ(sv.Get(1), base::nullopt);
+  ASSERT_EQ(sv.Get(1), std::nullopt);
   ASSERT_EQ(sv.Get(2), 2);
   ASSERT_EQ(sv.Get(3), 3);
-  ASSERT_EQ(sv.Get(4), base::nullopt);
+  ASSERT_EQ(sv.Get(4), std::nullopt);
 
   sv.Set(1, 1);
   ASSERT_EQ(sv.Get(1), 1);
diff --git a/src/trace_processor/containers/row_map.h b/src/trace_processor/containers/row_map.h
index 06d650a..8ab3915 100644
--- a/src/trace_processor/containers/row_map.h
+++ b/src/trace_processor/containers/row_map.h
@@ -20,10 +20,10 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 #include <vector>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/containers/bit_vector.h"
 #include "src/trace_processor/containers/bit_vector_iterators.h"
 
@@ -305,24 +305,24 @@
   }
 
   // Returns the first row of the given |index| in the RowMap.
-  base::Optional<InputRow> RowOf(OutputIndex index) const {
+  std::optional<InputRow> RowOf(OutputIndex index) const {
     switch (mode_) {
       case Mode::kRange: {
         if (index < start_index_ || index >= end_index_)
-          return base::nullopt;
+          return std::nullopt;
         return index - start_index_;
       }
       case Mode::kBitVector: {
         return index < bit_vector_.size() && bit_vector_.IsSet(index)
-                   ? base::make_optional(bit_vector_.CountSetBits(index))
-                   : base::nullopt;
+                   ? std::make_optional(bit_vector_.CountSetBits(index))
+                   : std::nullopt;
       }
       case Mode::kIndexVector: {
         auto it = std::find(index_vector_.begin(), index_vector_.end(), index);
         return it != index_vector_.end()
-                   ? base::make_optional(static_cast<InputRow>(
+                   ? std::make_optional(static_cast<InputRow>(
                          std::distance(index_vector_.begin(), it)))
-                   : base::nullopt;
+                   : std::nullopt;
       }
     }
     PERFETTO_FATAL("For GCC");
diff --git a/src/trace_processor/containers/row_map_unittest.cc b/src/trace_processor/containers/row_map_unittest.cc
index 5be6c06..6e1ca11 100644
--- a/src/trace_processor/containers/row_map_unittest.cc
+++ b/src/trace_processor/containers/row_map_unittest.cc
@@ -34,11 +34,11 @@
   ASSERT_EQ(rm.Get(1), 31u);
   ASSERT_EQ(rm.Get(16), 46u);
 
-  ASSERT_EQ(rm.RowOf(29), base::nullopt);
+  ASSERT_EQ(rm.RowOf(29), std::nullopt);
   ASSERT_EQ(rm.RowOf(30), 0u);
   ASSERT_EQ(rm.RowOf(37), 7u);
   ASSERT_EQ(rm.RowOf(46), 16u);
-  ASSERT_EQ(rm.RowOf(47), base::nullopt);
+  ASSERT_EQ(rm.RowOf(47), std::nullopt);
 }
 
 TEST(RowMapUnittest, SmokeBitVector) {
@@ -54,8 +54,8 @@
   ASSERT_EQ(rm.RowOf(4u), 1u);
   ASSERT_EQ(rm.RowOf(5u), 2u);
 
-  ASSERT_EQ(rm.RowOf(1u), base::nullopt);
-  ASSERT_EQ(rm.RowOf(100u), base::nullopt);
+  ASSERT_EQ(rm.RowOf(1u), std::nullopt);
+  ASSERT_EQ(rm.RowOf(100u), std::nullopt);
 }
 
 TEST(RowMapUnittest, SmokeIndexVector) {
diff --git a/src/trace_processor/containers/string_pool.h b/src/trace_processor/containers/string_pool.h
index ddc57cd..73e0e2b 100644
--- a/src/trace_processor/containers/string_pool.h
+++ b/src/trace_processor/containers/string_pool.h
@@ -21,11 +21,11 @@
 #include <stdint.h>
 
 #include <limits>
+#include <optional>
 #include <vector>
 
 #include "perfetto/ext/base/flat_hash_map.h"
 #include "perfetto/ext/base/hash.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/paged_memory.h"
 #include "perfetto/protozero/proto_utils.h"
 #include "src/trace_processor/containers/null_term_string_view.h"
@@ -132,7 +132,7 @@
     return *id;
   }
 
-  base::Optional<Id> GetId(base::StringView str) const {
+  std::optional<Id> GetId(base::StringView str) const {
     if (str.data() == nullptr)
       return Id::Null();
 
@@ -142,7 +142,7 @@
       PERFETTO_DCHECK(Get(*id) == str);
       return *id;
     }
-    return base::nullopt;
+    return std::nullopt;
   }
 
   NullTermStringView Get(Id id) const {
diff --git a/src/trace_processor/db/column.cc b/src/trace_processor/db/column.cc
index 4fec8fc..01c6b5e 100644
--- a/src/trace_processor/db/column.cc
+++ b/src/trace_processor/db/column.cc
@@ -56,16 +56,16 @@
     bool is_storage_dense;
     switch (type_) {
       case ColumnType::kInt32:
-        is_storage_dense = storage<base::Optional<int32_t>>().IsDense();
+        is_storage_dense = storage<std::optional<int32_t>>().IsDense();
         break;
       case ColumnType::kUint32:
-        is_storage_dense = storage<base::Optional<uint32_t>>().IsDense();
+        is_storage_dense = storage<std::optional<uint32_t>>().IsDense();
         break;
       case ColumnType::kInt64:
-        is_storage_dense = storage<base::Optional<int64_t>>().IsDense();
+        is_storage_dense = storage<std::optional<int64_t>>().IsDense();
         break;
       case ColumnType::kDouble:
-        is_storage_dense = storage<base::Optional<double>>().IsDense();
+        is_storage_dense = storage<std::optional<double>>().IsDense();
         break;
       case ColumnType::kString:
         PERFETTO_FATAL("String column should not be nullable");
@@ -159,7 +159,7 @@
     PERFETTO_DCHECK(value.is_null());
     if (is_nullable) {
       overlay().FilterInto(rm, [this](uint32_t row) {
-        return !storage<base::Optional<T>>().Get(row).has_value();
+        return !storage<std::optional<T>>().Get(row).has_value();
       });
     } else {
       rm->Clear();
@@ -169,7 +169,7 @@
     PERFETTO_DCHECK(value.is_null());
     if (is_nullable) {
       overlay().FilterInto(rm, [this](uint32_t row) {
-        return storage<base::Optional<T>>().Get(row).has_value();
+        return storage<std::optional<T>>().Get(row).has_value();
       });
     }
     return;
@@ -227,7 +227,7 @@
     case FilterOp::kLt:
       overlay().FilterInto(rm, [this, &cmp](uint32_t idx) {
         if (is_nullable) {
-          auto opt_value = storage<base::Optional<T>>().Get(idx);
+          auto opt_value = storage<std::optional<T>>().Get(idx);
           return opt_value && cmp(*opt_value) < 0;
         }
         return cmp(storage<T>().Get(idx)) < 0;
@@ -236,7 +236,7 @@
     case FilterOp::kEq:
       overlay().FilterInto(rm, [this, &cmp](uint32_t idx) {
         if (is_nullable) {
-          auto opt_value = storage<base::Optional<T>>().Get(idx);
+          auto opt_value = storage<std::optional<T>>().Get(idx);
           return opt_value && cmp(*opt_value) == 0;
         }
         return cmp(storage<T>().Get(idx)) == 0;
@@ -245,7 +245,7 @@
     case FilterOp::kGt:
       overlay().FilterInto(rm, [this, &cmp](uint32_t idx) {
         if (is_nullable) {
-          auto opt_value = storage<base::Optional<T>>().Get(idx);
+          auto opt_value = storage<std::optional<T>>().Get(idx);
           return opt_value && cmp(*opt_value) > 0;
         }
         return cmp(storage<T>().Get(idx)) > 0;
@@ -254,7 +254,7 @@
     case FilterOp::kNe:
       overlay().FilterInto(rm, [this, &cmp](uint32_t idx) {
         if (is_nullable) {
-          auto opt_value = storage<base::Optional<T>>().Get(idx);
+          auto opt_value = storage<std::optional<T>>().Get(idx);
           return opt_value && cmp(*opt_value) != 0;
         }
         return cmp(storage<T>().Get(idx)) != 0;
@@ -263,7 +263,7 @@
     case FilterOp::kLe:
       overlay().FilterInto(rm, [this, &cmp](uint32_t idx) {
         if (is_nullable) {
-          auto opt_value = storage<base::Optional<T>>().Get(idx);
+          auto opt_value = storage<std::optional<T>>().Get(idx);
           return opt_value && cmp(*opt_value) <= 0;
         }
         return cmp(storage<T>().Get(idx)) <= 0;
@@ -272,7 +272,7 @@
     case FilterOp::kGe:
       overlay().FilterInto(rm, [this, &cmp](uint32_t idx) {
         if (is_nullable) {
-          auto opt_value = storage<base::Optional<T>>().Get(idx);
+          auto opt_value = storage<std::optional<T>>().Get(idx);
           return opt_value && cmp(*opt_value) >= 0;
         }
         return cmp(storage<T>().Get(idx)) >= 0;
@@ -486,8 +486,8 @@
 
   overlay().StableSort(out, [this](uint32_t a_idx, uint32_t b_idx) {
     if (is_nullable) {
-      auto a_val = storage<base::Optional<T>>().Get(a_idx);
-      auto b_val = storage<base::Optional<T>>().Get(b_idx);
+      auto a_val = storage<std::optional<T>>().Get(a_idx);
+      auto b_val = storage<std::optional<T>>().Get(b_idx);
 
       int res = compare::NullableNumeric(a_val, b_val);
       return desc ? res > 0 : res < 0;
diff --git a/src/trace_processor/db/column.h b/src/trace_processor/db/column.h
index 1d1b347..04425b9 100644
--- a/src/trace_processor/db/column.h
+++ b/src/trace_processor/db/column.h
@@ -18,9 +18,9 @@
 #define SRC_TRACE_PROCESSOR_DB_COLUMN_H_
 
 #include <stdint.h>
+#include <optional>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/trace_processor/basic_types.h"
 #include "src/trace_processor/containers/row_map.h"
 #include "src/trace_processor/containers/string_pool.h"
@@ -100,7 +100,7 @@
   static constexpr ColumnType ToColumnType() { return ColumnType::kString; }
 };
 template <typename T>
-struct ColumnTypeHelper<base::Optional<T>> : public ColumnTypeHelper<T> {};
+struct ColumnTypeHelper<std::optional<T>> : public ColumnTypeHelper<T> {};
 
 class Table;
 
@@ -262,7 +262,7 @@
   SqlValue Get(uint32_t row) const { return GetAtIdx(overlay().Get(row)); }
 
   // Returns the row containing the given value in the Column.
-  base::Optional<uint32_t> IndexOf(SqlValue value) const {
+  std::optional<uint32_t> IndexOf(SqlValue value) const {
     switch (type_) {
       // TODO(lalitm): investigate whether we could make this more efficient
       // by first checking the type of the column and comparing explicitly
@@ -276,11 +276,11 @@
           if (compare::SqlValue(Get(i), value) == 0)
             return i;
         }
-        return base::nullopt;
+        return std::nullopt;
       }
       case ColumnType::kId: {
         if (value.type != SqlValue::Type::kLong)
-          return base::nullopt;
+          return std::nullopt;
         return overlay().RowOf(static_cast<uint32_t>(value.long_value));
       }
       case ColumnType::kDummy:
@@ -328,11 +328,11 @@
     FilterIntoSlow(op, value, rm);
   }
 
-  // Returns the minimum value in this column. Returns nullopt if this column
-  // is empty.
-  base::Optional<SqlValue> Min() const {
+  // Returns the minimum value in this column. Returns std::nullopt if this
+  // column is empty.
+  std::optional<SqlValue> Min() const {
     if (overlay().empty())
-      return base::nullopt;
+      return std::nullopt;
 
     if (IsSorted())
       return Get(0);
@@ -342,11 +342,11 @@
     return *std::min_element(b, e, &compare::SqlValueComparator);
   }
 
-  // Returns the minimum value in this column. Returns nullopt if this column
-  // is empty.
-  base::Optional<SqlValue> Max() const {
+  // Returns the minimum value in this column. Returns std::nullopt if this
+  // column is empty.
+  std::optional<SqlValue> Max() const {
     if (overlay().empty())
-      return base::nullopt;
+      return std::nullopt;
 
     if (IsSorted())
       return Get(overlay().size() - 1);
@@ -525,7 +525,7 @@
   template <typename T>
   SqlValue GetAtIdxTyped(uint32_t idx) const {
     if (IsNullable()) {
-      auto opt_value = storage<base::Optional<T>>().Get(idx);
+      auto opt_value = storage<std::optional<T>>().Get(idx);
       return opt_value ? ToSqlValue(*opt_value) : SqlValue();
     }
     return ToSqlValue(storage<T>().Get(idx));
diff --git a/src/trace_processor/db/column_storage.h b/src/trace_processor/db/column_storage.h
index 70c8385..6cf2f30 100644
--- a/src/trace_processor/db/column_storage.h
+++ b/src/trace_processor/db/column_storage.h
@@ -66,7 +66,7 @@
 
 // Class used for implementing storage for nullable columns.
 template <typename T>
-class ColumnStorage<base::Optional<T>> : public ColumnStorageBase {
+class ColumnStorage<std::optional<T>> : public ColumnStorageBase {
  public:
   ColumnStorage() = default;
 
@@ -76,19 +76,19 @@
   ColumnStorage(ColumnStorage&&) = default;
   ColumnStorage& operator=(ColumnStorage&&) noexcept = default;
 
-  base::Optional<T> Get(uint32_t idx) const { return nv_.Get(idx); }
+  std::optional<T> Get(uint32_t idx) const { return nv_.Get(idx); }
   void Append(T val) { nv_.Append(val); }
-  void Append(base::Optional<T> val) { nv_.Append(std::move(val)); }
+  void Append(std::optional<T> val) { nv_.Append(std::move(val)); }
   void Set(uint32_t idx, T val) { nv_.Set(idx, val); }
   uint32_t size() const { return nv_.size(); }
   bool IsDense() const { return nv_.IsDense(); }
   void ShrinkToFit() { nv_.ShrinkToFit(); }
 
   template <bool IsDense>
-  static ColumnStorage<base::Optional<T>> Create() {
+  static ColumnStorage<std::optional<T>> Create() {
     return IsDense
-               ? ColumnStorage<base::Optional<T>>(NullableVector<T>::Dense())
-               : ColumnStorage<base::Optional<T>>(NullableVector<T>::Sparse());
+               ? ColumnStorage<std::optional<T>>(NullableVector<T>::Dense())
+               : ColumnStorage<std::optional<T>>(NullableVector<T>::Sparse());
   }
 
  private:
diff --git a/src/trace_processor/db/column_storage_overlay.h b/src/trace_processor/db/column_storage_overlay.h
index dad6c82..108dccd 100644
--- a/src/trace_processor/db/column_storage_overlay.h
+++ b/src/trace_processor/db/column_storage_overlay.h
@@ -20,10 +20,10 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 #include <vector>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/containers/bit_vector.h"
 #include "src/trace_processor/containers/bit_vector_iterators.h"
 #include "src/trace_processor/containers/row_map.h"
@@ -113,7 +113,7 @@
   OutputIndex Get(uint32_t row) const { return row_map_.Get(row); }
 
   // Returns the first row of the given |index| in the ColumnStorageOverlay.
-  base::Optional<InputRow> RowOf(OutputIndex index) const {
+  std::optional<InputRow> RowOf(OutputIndex index) const {
     return row_map_.RowOf(index);
   }
 
diff --git a/src/trace_processor/db/compare.h b/src/trace_processor/db/compare.h
index 3aeefbb..e118294 100644
--- a/src/trace_processor/db/compare.h
+++ b/src/trace_processor/db/compare.h
@@ -20,8 +20,8 @@
 #include <stdint.h>
 
 #include <algorithm>
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/trace_processor/basic_types.h"
 
@@ -112,7 +112,7 @@
 // This method was defined from observing the behaviour of SQLite when sorting
 // on columns containing nulls.
 template <typename T>
-inline int NullableNumeric(base::Optional<T> a, base::Optional<T> b) {
+inline int NullableNumeric(std::optional<T> a, std::optional<T> b) {
   if (!a)
     return b ? -1 : 0;
 
diff --git a/src/trace_processor/db/table.h b/src/trace_processor/db/table.h
index 21962bf..c1cf66c 100644
--- a/src/trace_processor/db/table.h
+++ b/src/trace_processor/db/table.h
@@ -21,10 +21,10 @@
 
 #include <limits>
 #include <numeric>
+#include <optional>
 #include <vector>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/containers/string_pool.h"
 #include "src/trace_processor/db/column.h"
 #include "src/trace_processor/db/column_storage_overlay.h"
@@ -148,19 +148,19 @@
   // Returns the column at index |idx| in the Table.
   const Column& GetColumn(uint32_t idx) const { return columns_[idx]; }
 
-  // Returns the column index with the given name or base::nullopt otherwise.
-  base::Optional<uint32_t> GetColumnIndexByName(const char* name) const {
+  // Returns the column index with the given name or std::nullopt otherwise.
+  std::optional<uint32_t> GetColumnIndexByName(const char* name) const {
     auto it = std::find_if(
         columns_.begin(), columns_.end(),
         [name](const Column& col) { return strcmp(col.name(), name) == 0; });
     if (it == columns_.end())
-      return base::nullopt;
+      return std::nullopt;
     return static_cast<uint32_t>(std::distance(columns_.begin(), it));
   }
 
   // Returns the column with the given name or nullptr otherwise.
   const Column* GetColumnByName(const char* name) const {
-    base::Optional<uint32_t> opt_idx = GetColumnIndexByName(name);
+    std::optional<uint32_t> opt_idx = GetColumnIndexByName(name);
     if (!opt_idx)
       return nullptr;
     return &columns_[*opt_idx];
diff --git a/src/trace_processor/db/table_unittest.cc b/src/trace_processor/db/table_unittest.cc
index e915ce2..6f370ca 100644
--- a/src/trace_processor/db/table_unittest.cc
+++ b/src/trace_processor/db/table_unittest.cc
@@ -15,7 +15,6 @@
  */
 
 #include "src/trace_processor/db/table.h"
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/db/typed_column.h"
 #include "src/trace_processor/tables/macros.h"
 
diff --git a/src/trace_processor/db/typed_column.h b/src/trace_processor/db/typed_column.h
index dae1b86..7bf0fad 100644
--- a/src/trace_processor/db/typed_column.h
+++ b/src/trace_processor/db/typed_column.h
@@ -91,7 +91,7 @@
   void Append(T v) { mutable_storage()->Append(Serializer::Serialize(v)); }
 
   // Returns the row containing the given value in the Column.
-  base::Optional<uint32_t> IndexOf(sql_value_type v) const {
+  std::optional<uint32_t> IndexOf(sql_value_type v) const {
     return Column::IndexOf(ToSqlValue(v));
   }
 
@@ -190,7 +190,7 @@
 
   Id operator[](uint32_t row) const { return Id(overlay().Get(row)); }
 
-  base::Optional<uint32_t> IndexOf(Id id) const {
+  std::optional<uint32_t> IndexOf(Id id) const {
     return overlay().RowOf(id.value);
   }
 
diff --git a/src/trace_processor/db/typed_column_internal.h b/src/trace_processor/db/typed_column_internal.h
index 5ffc811..634feac 100644
--- a/src/trace_processor/db/typed_column_internal.h
+++ b/src/trace_processor/db/typed_column_internal.h
@@ -34,10 +34,10 @@
   static serialized_type Serialize(T value) { return value; }
   static T Deserialize(serialized_type value) { return value; }
 
-  static base::Optional<serialized_type> Serialize(base::Optional<T> value) {
+  static std::optional<serialized_type> Serialize(std::optional<T> value) {
     return value;
   }
-  static base::Optional<T> Deserialize(base::Optional<serialized_type> value) {
+  static std::optional<T> Deserialize(std::optional<serialized_type> value) {
     return value;
   }
 };
@@ -53,11 +53,11 @@
   static serialized_type Serialize(T value) { return value.value; }
   static T Deserialize(serialized_type value) { return T{value}; }
 
-  static base::Optional<serialized_type> Serialize(base::Optional<T> value) {
-    return value ? base::make_optional(Serialize(*value)) : base::nullopt;
+  static std::optional<serialized_type> Serialize(std::optional<T> value) {
+    return value ? std::make_optional(Serialize(*value)) : std::nullopt;
   }
-  static base::Optional<T> Deserialize(base::Optional<serialized_type> value) {
-    return value ? base::make_optional(Deserialize(*value)) : base::nullopt;
+  static std::optional<T> Deserialize(std::optional<serialized_type> value) {
+    return value ? std::make_optional(Deserialize(*value)) : std::nullopt;
   }
 };
 
@@ -69,10 +69,10 @@
   static serialized_type Serialize(StringPool::Id value) { return value; }
   static StringPool::Id Deserialize(serialized_type value) { return value; }
 
-  static serialized_type Serialize(base::Optional<StringPool::Id> value) {
+  static serialized_type Serialize(std::optional<StringPool::Id> value) {
     // Since StringPool::Id == 0 is always treated as null, rewrite
-    // base::nullopt -> 0 to remove an extra check at filter time for
-    // base::nullopt. Instead, that code can assume that the ColumnStorage
+    // std::nullopt -> 0 to remove an extra check at filter time for
+    // std::nullopt. Instead, that code can assume that the ColumnStorage
     // layer always returns a valid id and can handle the nullability at the
     // stringpool level.
     // TODO(lalitm): remove this special casing if we migrate all tables over
@@ -80,8 +80,8 @@
     // in the stringpool.
     return value ? Serialize(*value) : StringPool::Id::Null();
   }
-  static base::Optional<serialized_type> Deserialize(
-      base::Optional<StringPool::Id> value) {
+  static std::optional<serialized_type> Deserialize(
+      std::optional<StringPool::Id> value) {
     return value;
   }
 };
@@ -113,12 +113,12 @@
 
 // Specialization for Optional types.
 template <typename T>
-struct TypeHandler<base::Optional<T>> {
+struct TypeHandler<std::optional<T>> {
   using non_optional_type = T;
   using sql_value_type =
       typename Serializer<non_optional_type>::serialized_type;
   using stored_type =
-      base::Optional<typename Serializer<non_optional_type>::serialized_type>;
+      std::optional<typename Serializer<non_optional_type>::serialized_type>;
 
   static constexpr bool is_optional = true;
   static constexpr bool is_string = false;
@@ -127,7 +127,7 @@
     return nv.Get(idx);
   }
 
-  static bool Equals(base::Optional<T> a, base::Optional<T> b) {
+  static bool Equals(std::optional<T> a, std::optional<T> b) {
     // We need to use equal_to here as it could be T == double and because we
     // enable all compile time warnings, we will get complaints if we just use
     // a == b. This is the same reason why we can't also just use equal_to using
@@ -138,7 +138,7 @@
   }
 };
 
-// Specialization for Optional<StringId> types.
+// Specialization for std::optional<StringId> types.
 template <>
 struct TypeHandler<StringPool::Id> {
   using non_optional_type = StringPool::Id;
@@ -156,30 +156,29 @@
   static bool Equals(StringPool::Id a, StringPool::Id b) { return a == b; }
 };
 
-// Specialization for Optional<StringId> types.
+// Specialization for std::optional<StringId> types.
 template <>
-struct TypeHandler<base::Optional<StringPool::Id>> {
-  // get_type removes the base::Optional since we convert base::nullopt ->
+struct TypeHandler<std::optional<StringPool::Id>> {
+  // get_type removes the base::Optional since we convert std::nullopt ->
   // StringPool::Id::Null (see Serializer<StringPool> above).
   using non_optional_type = StringPool::Id;
   using sql_value_type = NullTermStringView;
   using stored_type = StringPool::Id;
 
   // is_optional is false again because we always unwrap
-  // base::Optional<StringPool::Id> into StringPool::Id.
+  // std::optional<StringPool::Id> into StringPool::Id.
   static constexpr bool is_optional = false;
   static constexpr bool is_string = true;
 
-  static base::Optional<StringPool::Id> Get(
-      const ColumnStorage<stored_type>& nv,
-      uint32_t idx) {
+  static std::optional<StringPool::Id> Get(const ColumnStorage<stored_type>& nv,
+                                           uint32_t idx) {
     StringPool::Id id = nv.Get(idx);
-    return id.is_null() ? base::nullopt : base::make_optional(id);
+    return id.is_null() ? std::nullopt : std::make_optional(id);
   }
 
-  static bool Equals(base::Optional<StringPool::Id> a,
-                     base::Optional<StringPool::Id> b) {
-    // To match our handling of treating base::nullopt ==
+  static bool Equals(std::optional<StringPool::Id> a,
+                     std::optional<StringPool::Id> b) {
+    // To match our handling of treating std::nullopt ==
     // StringPool::Id::Null(), ensure that they both compare equal to each
     // other.
     return a == b || (!a && b->is_null()) || (!b && a->is_null());
diff --git a/src/trace_processor/db/view.cc b/src/trace_processor/db/view.cc
index 1855329..5b462c7 100644
--- a/src/trace_processor/db/view.cc
+++ b/src/trace_processor/db/view.cc
@@ -55,10 +55,10 @@
                           std::initializer_list<JoinTable> joins,
                           std::initializer_list<OutputColumn> cols,
                           View* view) {
-  // Insert the node for the root table; the column indices being nullopt
+  // Insert the node for the root table; the column indices being std::nullopt
   // indicates this is the root.
   std::unique_ptr<TableNode> root_node(
-      new TableNode{root_table, base::nullopt, base::nullopt, JoinFlag::kNoFlag,
+      new TableNode{root_table, std::nullopt, std::nullopt, JoinFlag::kNoFlag,
                     TableNode::Children{}});
   base::FlatHashMap<base::StringView, TableNode*> node_map;
   node_map.Insert(root_table_name, root_node.get());
@@ -78,7 +78,7 @@
     TableNode* prev_node = *prev_node_it;
 
     // Verify that the previous table's column exists.
-    base::Optional<uint32_t> opt_prev_col_idx =
+    std::optional<uint32_t> opt_prev_col_idx =
         prev_node->table->GetColumnIndexByName(join.prev_col);
     if (!opt_prev_col_idx) {
       return base::ErrStatus(
@@ -87,7 +87,7 @@
     }
 
     // Verify that the current table's column exists.
-    base::Optional<uint32_t> opt_col_idx =
+    std::optional<uint32_t> opt_col_idx =
         join.table->GetColumnIndexByName(join.col);
     if (!opt_col_idx) {
       return base::ErrStatus(
@@ -304,7 +304,7 @@
     right_rm_iv.reserve(left_rm.size());
     left_col.overlay().FilterInto(&left_rm, [&](uint32_t idx) {
       // Check if the right table has the value from the left table.
-      base::Optional<uint32_t> opt_idx =
+      std::optional<uint32_t> opt_idx =
           right_col.IndexOf(left_col.GetAtIdx(idx));
 
       // If it doesn't, return false indicating that this row should be
diff --git a/src/trace_processor/db/view.h b/src/trace_processor/db/view.h
index 66c8564..8f830f8 100644
--- a/src/trace_processor/db/view.h
+++ b/src/trace_processor/db/view.h
@@ -22,13 +22,13 @@
 #include <iterator>
 #include <memory>
 #include <numeric>
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "perfetto/base/logging.h"
 #include "perfetto/base/status.h"
 #include "perfetto/ext/base/flat_hash_map.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/small_vector.h"
 #include "perfetto/trace_processor/iterator.h"
 #include "src/trace_processor/containers/bit_vector.h"
@@ -208,11 +208,11 @@
     // The index of the id column in |table|.
     // In practice, this will always be zero (as id columns are implicitly the
     // first column) but having this allows flexibility for the future.
-    base::Optional<uint32_t> join_col_idx;
+    std::optional<uint32_t> join_col_idx;
 
     // The index of the column in the parent table which is selecting the rows
     // in |table|.
-    base::Optional<uint32_t> parent_join_col_idx;
+    std::optional<uint32_t> parent_join_col_idx;
 
     // Set of bitwise-ORed flags modifying how the join should be perfomed. See
     // |JoinFlag| struct for potential flags.
diff --git a/src/trace_processor/export_json.cc b/src/trace_processor/export_json.cc
index 7709681..dcac72d 100644
--- a/src/trace_processor/export_json.cc
+++ b/src/trace_processor/export_json.cc
@@ -86,8 +86,8 @@
 const char kStrippedArgument[] = "__stripped__";
 
 const char* GetNonNullString(const TraceStorage* storage,
-                             base::Optional<StringId> id) {
-  return id == base::nullopt || *id == kNullStringId
+                             std::optional<StringId> id) {
+  return id == std::nullopt || *id == kNullStringId
              ? ""
              : storage->GetString(*id).c_str();
 }
@@ -608,7 +608,7 @@
                             args_sets_[set_id].toStyledString().c_str());
               return;
             }
-            base::Optional<uint32_t> index = base::StringToUInt32(s);
+            std::optional<uint32_t> index = base::StringToUInt32(s);
             if (PERFETTO_UNLIKELY(!index)) {
               PERFETTO_ELOG("Expected to be able to extract index from %s",
                             key_part.c_str());
@@ -683,7 +683,7 @@
     const auto& thread_table = storage_->thread_table();
     for (UniqueTid utid = 0; utid < thread_table.row_count(); utid++) {
       uint32_t exported_pid = 0;
-      base::Optional<UniquePid> upid = thread_table.upid()[utid];
+      std::optional<UniquePid> upid = thread_table.upid()[utid];
       if (upid) {
         auto exported_pid_it = upids_to_exported_pids_.find(*upid);
         PERFETTO_DCHECK(exported_pid_it != upids_to_exported_pids_.end());
@@ -742,7 +742,7 @@
 
     const auto& process_table = storage_->process_table();
     for (UniquePid upid = 0; upid < process_table.row_count(); ++upid) {
-      base::Optional<int64_t> start_timestamp_ns =
+      std::optional<int64_t> start_timestamp_ns =
           process_table.start_ts()[upid];
       if (!start_timestamp_ns.has_value())
         continue;
@@ -795,7 +795,7 @@
       event["pid"] = 0;
       event["tid"] = 0;
 
-      base::Optional<UniqueTid> legacy_utid;
+      std::optional<UniqueTid> legacy_utid;
       std::string legacy_phase;
 
       event["args"] = args_builder_.GetArgs(it.arg_set_id());  // Makes a copy.
@@ -837,10 +837,10 @@
       const auto& virtual_track_slices = storage_->virtual_track_slices();
 
       int64_t duration_ns = it.dur();
-      base::Optional<int64_t> thread_ts_ns;
-      base::Optional<int64_t> thread_duration_ns;
-      base::Optional<int64_t> thread_instruction_count;
-      base::Optional<int64_t> thread_instruction_delta;
+      std::optional<int64_t> thread_ts_ns;
+      std::optional<int64_t> thread_duration_ns;
+      std::optional<int64_t> thread_instruction_count;
+      std::optional<int64_t> thread_instruction_delta;
 
       if (it.thread_dur()) {
         thread_ts_ns = it.thread_ts();
@@ -849,7 +849,7 @@
         thread_instruction_delta = it.thread_instruction_delta();
       } else {
         SliceId id = it.id();
-        base::Optional<uint32_t> vtrack_slice_row =
+        std::optional<uint32_t> vtrack_slice_row =
             virtual_track_slices.FindRowForSliceId(id);
         if (vtrack_slice_row) {
           thread_ts_ns =
@@ -1054,25 +1054,25 @@
     return util::OkStatus();
   }
 
-  base::Optional<Json::Value> CreateFlowEventV1(uint32_t flow_id,
-                                                SliceId slice_id,
-                                                std::string name,
-                                                std::string cat,
-                                                Json::Value args,
-                                                bool flow_begin) {
+  std::optional<Json::Value> CreateFlowEventV1(uint32_t flow_id,
+                                               SliceId slice_id,
+                                               std::string name,
+                                               std::string cat,
+                                               Json::Value args,
+                                               bool flow_begin) {
     const auto& slices = storage_->slice_table();
     const auto& thread_tracks = storage_->thread_track_table();
 
     auto opt_slice_idx = slices.id().IndexOf(slice_id);
     if (!opt_slice_idx)
-      return base::nullopt;
+      return std::nullopt;
     uint32_t slice_idx = opt_slice_idx.value();
 
     TrackId track_id = storage_->slice_table().track_id()[slice_idx];
     auto opt_thread_track_idx = thread_tracks.id().IndexOf(track_id);
     // catapult only supports flow events attached to thread-track slices
     if (!opt_thread_track_idx)
-      return base::nullopt;
+      return std::nullopt;
 
     UniqueTid utid = thread_tracks.utid()[opt_thread_track_idx.value()];
     auto pid_and_tid = UtidToPidAndTid(utid);
@@ -1112,9 +1112,9 @@
       } else {
         auto opt_slice_out_idx = slice_table.id().IndexOf(slice_out);
         PERFETTO_DCHECK(opt_slice_out_idx.has_value());
-        base::Optional<StringId> cat_id =
+        std::optional<StringId> cat_id =
             slice_table.category()[opt_slice_out_idx.value()];
-        base::Optional<StringId> name_id =
+        std::optional<StringId> name_id =
             slice_table.name()[opt_slice_out_idx.value()];
         cat = GetNonNullString(storage_, cat_id);
         name = GetNonNullString(storage_, name_id);
@@ -1211,13 +1211,13 @@
   }
 
   util::Status ExportRawEvents() {
-    base::Optional<StringId> raw_legacy_event_key_id =
+    std::optional<StringId> raw_legacy_event_key_id =
         storage_->string_pool().GetId("track_event.legacy_event");
-    base::Optional<StringId> raw_legacy_system_trace_event_id =
+    std::optional<StringId> raw_legacy_system_trace_event_id =
         storage_->string_pool().GetId("chrome_event.legacy_system_trace");
-    base::Optional<StringId> raw_legacy_user_trace_event_id =
+    std::optional<StringId> raw_legacy_user_trace_event_id =
         storage_->string_pool().GetId("chrome_event.legacy_user_trace");
-    base::Optional<StringId> raw_chrome_metadata_event_id =
+    std::optional<StringId> raw_chrome_metadata_event_id =
         storage_->string_pool().GetId("chrome_event.metadata");
 
     const auto& events = storage_->raw_table();
@@ -1393,7 +1393,7 @@
       const auto& mappings = storage_->stack_profile_mapping_table();
 
       std::vector<std::string> callstack;
-      base::Optional<CallsiteId> opt_callsite_id = samples.callsite_id()[i];
+      std::optional<CallsiteId> opt_callsite_id = samples.callsite_id()[i];
 
       while (opt_callsite_id) {
         CallsiteId callsite_id = *opt_callsite_id;
@@ -1445,7 +1445,7 @@
       // For now, only do this when the trace has already been symbolized i.e.
       // are not directly output by Chrome, to avoid interfering with other
       // processing pipelines.
-      base::Optional<CallsiteId> opt_current_callsite_id =
+      std::optional<CallsiteId> opt_current_callsite_id =
           samples.callsite_id()[i];
 
       if (opt_current_callsite_id && storage_->symbol_table().row_count() > 0) {
@@ -1556,9 +1556,9 @@
 
   util::Status ExportMemorySnapshots() {
     const auto& memory_snapshots = storage_->memory_snapshot_table();
-    base::Optional<StringId> private_footprint_id =
+    std::optional<StringId> private_footprint_id =
         storage_->string_pool().GetId("chrome.private_footprint_kb");
-    base::Optional<StringId> peak_resident_set_id =
+    std::optional<StringId> peak_resident_set_id =
         storage_->string_pool().GetId("chrome.peak_resident_set_kb");
 
     for (uint32_t memory_index = 0; memory_index < memory_snapshots.row_count();
diff --git a/src/trace_processor/export_json_unittest.cc b/src/trace_processor/export_json_unittest.cc
index 823bc17..61d0976 100644
--- a/src/trace_processor/export_json_unittest.cc
+++ b/src/trace_processor/export_json_unittest.cc
@@ -830,16 +830,16 @@
 
 TEST_F(ExportJsonTest, DuplicatePidAndTid) {
   UniqueTid upid1 = context_.process_tracker->StartNewProcess(
-      base::nullopt, base::nullopt, 1, kNullStringId,
+      std::nullopt, std::nullopt, 1, kNullStringId,
       ThreadNamePriority::kTrackDescriptor);
   UniqueTid utid1a = context_.process_tracker->UpdateThread(1, 1);
   UniqueTid utid1b = context_.process_tracker->UpdateThread(2, 1);
-  UniqueTid utid1c = context_.process_tracker->StartNewThread(base::nullopt, 2);
+  UniqueTid utid1c = context_.process_tracker->StartNewThread(std::nullopt, 2);
   // Associate the new thread with its process.
   ASSERT_EQ(utid1c, context_.process_tracker->UpdateThread(2, 1));
 
   UniqueTid upid2 = context_.process_tracker->StartNewProcess(
-      base::nullopt, base::nullopt, 1, kNullStringId,
+      std::nullopt, std::nullopt, 1, kNullStringId,
       ThreadNamePriority::kTrackDescriptor);
   UniqueTid utid2a = context_.process_tracker->UpdateThread(1, 1);
   UniqueTid utid2b = context_.process_tracker->UpdateThread(2, 1);
@@ -1542,7 +1542,7 @@
        storage->InternString("bar_file"), 77});
   frames->mutable_symbol_set_id()->Set(frame_2.row, symbol_set_id);
 
-  auto frame_callsite_1 = callsites->Insert({0, base::nullopt, frame_1.id});
+  auto frame_callsite_1 = callsites->Insert({0, std::nullopt, frame_1.id});
 
   auto frame_callsite_2 =
       callsites->Insert({1, frame_callsite_1.id, frame_2.id});
diff --git a/src/trace_processor/importers/android_bugreport/android_bugreport_parser.cc b/src/trace_processor/importers/android_bugreport/android_bugreport_parser.cc
index 5e80c24..87aa0f5 100644
--- a/src/trace_processor/importers/android_bugreport/android_bugreport_parser.cc
+++ b/src/trace_processor/importers/android_bugreport/android_bugreport_parser.cc
@@ -17,9 +17,9 @@
 #include "src/trace_processor/importers/android_bugreport/android_bugreport_parser.h"
 
 #include <algorithm>
+#include <optional>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/trace_processor/trace_blob.h"
 #include "perfetto/trace_processor/trace_blob_view.h"
@@ -247,7 +247,7 @@
   // Typical name: "bugreport-product-TP1A.220623.001-2022-06-24-16-24-37.txt".
   auto year_str = br_file->name().substr(
       br_file->name().size() - strlen("2022-12-31-23-59-00.txt"), 4);
-  base::Optional<int32_t> year = base::StringToInt32(year_str);
+  std::optional<int32_t> year = base::StringToInt32(year_str);
   if (!year.has_value()) {
     PERFETTO_ELOG("Could not parse the year from %s", br_file->name().c_str());
     return false;
diff --git a/src/trace_processor/importers/android_bugreport/android_log_parser.cc b/src/trace_processor/importers/android_bugreport/android_log_parser.cc
index cf42150..b825862 100644
--- a/src/trace_processor/importers/android_bugreport/android_log_parser.cc
+++ b/src/trace_processor/importers/android_bugreport/android_log_parser.cc
@@ -17,10 +17,10 @@
 #include "src/trace_processor/importers/android_bugreport/android_log_parser.h"
 
 #include <string.h>
+#include <optional>
 
 #include "perfetto/base/logging.h"
 #include "perfetto/base/time.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "src/trace_processor/types/trace_processor_context.h"
 
@@ -42,9 +42,9 @@
 //      input="123",  decimal_scale=1000 -> res=123
 //      input="1234", decimal_scale=1000 -> res=123
 //      input="1234", decimal_scale=1000000 -> res=123400
-base::Optional<int> ReadNumAndAdvance(base::StringView* it,
-                                      char sep,
-                                      int decimal_scale = 0) {
+std::optional<int> ReadNumAndAdvance(base::StringView* it,
+                                     char sep,
+                                     int decimal_scale = 0) {
   int num = 0;
   bool sep_found = false;
   size_t next_it = 0;
@@ -73,13 +73,14 @@
     invalid_chars_found = true;
   }
   if (!sep_found)
-    return base::nullopt;
+    return std::nullopt;
   // If we find non-digit characters, we want to still skip the token but return
-  // nullopt. The parser below relies on token skipping to deal with cases where
-  // the uid (which we don't care about) is literal ("root" rather than 0).
+  // std::nullopt. The parser below relies on token skipping to deal with cases
+  // where the uid (which we don't care about) is literal ("root" rather than
+  // 0).
   *it = it->substr(next_it);
   if (invalid_chars_found)
-    return base::nullopt;
+    return std::nullopt;
   return num;
 }
 
@@ -146,18 +147,18 @@
     // 06-24 16:24:23.441532 23153 23153 I wm_on_stop_called: message ...
     // 07-28 14:25:13.506  root     0     0 I x86/fpu : Supporting XSAVE feature
     // 0x002: 'SSE registers'
-    base::Optional<int> month = ReadNumAndAdvance(&it, '-');
-    base::Optional<int> day = ReadNumAndAdvance(&it, ' ');
-    base::Optional<int> hour = ReadNumAndAdvance(&it, ':');
-    base::Optional<int> minute = ReadNumAndAdvance(&it, ':');
-    base::Optional<int> sec = ReadNumAndAdvance(&it, '.');
-    base::Optional<int> ns = ReadNumAndAdvance(&it, ' ', 1000 * 1000 * 1000);
+    std::optional<int> month = ReadNumAndAdvance(&it, '-');
+    std::optional<int> day = ReadNumAndAdvance(&it, ' ');
+    std::optional<int> hour = ReadNumAndAdvance(&it, ':');
+    std::optional<int> minute = ReadNumAndAdvance(&it, ':');
+    std::optional<int> sec = ReadNumAndAdvance(&it, '.');
+    std::optional<int> ns = ReadNumAndAdvance(&it, ' ', 1000 * 1000 * 1000);
 
     if (fmt == LogcatFormat::kBugreport)
       ReadNumAndAdvance(&it, ' ');  // Skip the UID column.
 
-    base::Optional<int> pid = ReadNumAndAdvance(&it, ' ');
-    base::Optional<int> tid = ReadNumAndAdvance(&it, ' ');
+    std::optional<int> pid = ReadNumAndAdvance(&it, ' ');
+    std::optional<int> tid = ReadNumAndAdvance(&it, ' ');
 
     if (!month || !day || !hour || !minute || !sec || !ns || !pid || !tid) {
       ++parse_failures;
diff --git a/src/trace_processor/importers/common/args_tracker.cc b/src/trace_processor/importers/common/args_tracker.cc
index 113c590..69eca73 100644
--- a/src/trace_processor/importers/common/args_tracker.cc
+++ b/src/trace_processor/importers/common/args_tracker.cc
@@ -82,7 +82,7 @@
     ArgSetId set_id =
         context_->global_args_tracker->AddArgSet(&args_[0], i, next_rid_idx);
     if (col->IsNullable()) {
-      TypedColumn<base::Optional<uint32_t>>::FromColumn(col)->Set(row, set_id);
+      TypedColumn<std::optional<uint32_t>>::FromColumn(col)->Set(row, set_id);
     } else {
       TypedColumn<uint32_t>::FromColumn(col)->Set(row, set_id);
     }
diff --git a/src/trace_processor/importers/common/args_translation_table.cc b/src/trace_processor/importers/common/args_translation_table.cc
index d1559e0..74cdc34 100644
--- a/src/trace_processor/importers/common/args_translation_table.cc
+++ b/src/trace_processor/importers/common/args_translation_table.cc
@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
-#include "src/trace_processor/importers/common/args_translation_table.h"
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/string_view.h"
+#include "src/trace_processor/importers/common/args_translation_table.h"
 
 namespace perfetto {
 namespace trace_processor {
@@ -105,8 +106,8 @@
 void ArgsTranslationTable::TranslateArgs(
     const ArgsTracker::CompactArgSet& arg_set,
     ArgsTracker::BoundInserter& inserter) const {
-  base::Optional<uint64_t> mapping_id;
-  base::Optional<uint64_t> rel_pc;
+  std::optional<uint64_t> mapping_id;
+  std::optional<uint64_t> rel_pc;
 
   for (const auto& arg : arg_set) {
     const auto key_type =
@@ -119,7 +120,7 @@
     switch (*key_type) {
       case KeyType::kChromeHistogramHash: {
         inserter.AddArg(interned_chrome_histogram_hash_key_, arg.value);
-        const base::Optional<base::StringView> translated_value =
+        const std::optional<base::StringView> translated_value =
             TranslateChromeHistogramHash(arg.value.uint_value);
         if (translated_value) {
           inserter.AddArg(
@@ -130,7 +131,7 @@
       }
       case KeyType::kChromeUserEventHash: {
         inserter.AddArg(interned_chrome_user_event_hash_key_, arg.value);
-        const base::Optional<base::StringView> translated_value =
+        const std::optional<base::StringView> translated_value =
             TranslateChromeUserEventHash(arg.value.uint_value);
         if (translated_value) {
           inserter.AddArg(
@@ -142,7 +143,7 @@
       case KeyType::kChromePerformanceMarkMarkHash: {
         inserter.AddArg(interned_chrome_performance_mark_mark_hash_key_,
                         arg.value);
-        const base::Optional<base::StringView> translated_value =
+        const std::optional<base::StringView> translated_value =
             TranslateChromePerformanceMarkMarkHash(arg.value.uint_value);
         if (translated_value) {
           inserter.AddArg(
@@ -154,7 +155,7 @@
       case KeyType::kChromePerformanceMarkSiteHash: {
         inserter.AddArg(interned_chrome_performance_mark_site_hash_key_,
                         arg.value);
-        const base::Optional<base::StringView> translated_value =
+        const std::optional<base::StringView> translated_value =
             TranslateChromePerformanceMarkSiteHash(arg.value.uint_value);
         if (translated_value) {
           inserter.AddArg(
@@ -164,7 +165,7 @@
         break;
       }
       case KeyType::kClassName: {
-        const base::Optional<StringId> translated_class_name =
+        const std::optional<StringId> translated_class_name =
             TranslateClassName(arg.value.string_value);
         if (translated_class_name) {
           inserter.AddArg(arg.flat_key, arg.key,
@@ -187,7 +188,7 @@
   EmitMojoMethodLocation(mapping_id, rel_pc, inserter);
 }
 
-base::Optional<ArgsTranslationTable::KeyType>
+std::optional<ArgsTranslationTable::KeyType>
 ArgsTranslationTable::KeyIdAndTypeToEnum(StringId flat_key_id,
                                          StringId key_id,
                                          Variadic::Type type) const {
@@ -215,66 +216,66 @@
       return KeyType::kClassName;
     }
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
-base::Optional<base::StringView>
+std::optional<base::StringView>
 ArgsTranslationTable::TranslateChromeHistogramHash(uint64_t hash) const {
   auto* value = chrome_histogram_hash_to_name_.Find(hash);
   if (!value) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return base::StringView(*value);
 }
 
-base::Optional<base::StringView>
+std::optional<base::StringView>
 ArgsTranslationTable::TranslateChromeUserEventHash(uint64_t hash) const {
   auto* value = chrome_user_event_hash_to_action_.Find(hash);
   if (!value) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return base::StringView(*value);
 }
 
-base::Optional<base::StringView>
+std::optional<base::StringView>
 ArgsTranslationTable::TranslateChromePerformanceMarkSiteHash(
     uint64_t hash) const {
   auto* value = chrome_performance_mark_site_hash_to_name_.Find(hash);
   if (!value) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return base::StringView(*value);
 }
 
-base::Optional<base::StringView>
+std::optional<base::StringView>
 ArgsTranslationTable::TranslateChromePerformanceMarkMarkHash(
     uint64_t hash) const {
   auto* value = chrome_performance_mark_mark_hash_to_name_.Find(hash);
   if (!value) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return base::StringView(*value);
 }
 
-base::Optional<ArgsTranslationTable::SourceLocation>
+std::optional<ArgsTranslationTable::SourceLocation>
 ArgsTranslationTable::TranslateNativeSymbol(MappingId mapping_id,
                                             uint64_t rel_pc) const {
   auto loc =
       native_symbol_to_location_.Find(std::make_pair(mapping_id, rel_pc));
   if (!loc) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return *loc;
 }
 
-base::Optional<StringId> ArgsTranslationTable::TranslateClassName(
+std::optional<StringId> ArgsTranslationTable::TranslateClassName(
     StringId obfuscated_class_name_id) const {
   return deobfuscation_mapping_table_.TranslateClass(obfuscated_class_name_id);
 }
 
 void ArgsTranslationTable::EmitMojoMethodLocation(
-    base::Optional<uint64_t> mapping_id,
-    base::Optional<uint64_t> rel_pc,
+    std::optional<uint64_t> mapping_id,
+    std::optional<uint64_t> rel_pc,
     ArgsTracker::BoundInserter& inserter) const {
   if (!mapping_id || !rel_pc) {
     return;
diff --git a/src/trace_processor/importers/common/args_translation_table.h b/src/trace_processor/importers/common/args_translation_table.h
index e1b3178..f5bb1b2 100644
--- a/src/trace_processor/importers/common/args_translation_table.h
+++ b/src/trace_processor/importers/common/args_translation_table.h
@@ -18,9 +18,9 @@
 #define SRC_TRACE_PROCESSOR_IMPORTERS_COMMON_ARGS_TRANSLATION_TABLE_H_
 
 #include <cstdint>
+#include <optional>
 
 #include "perfetto/ext/base/flat_hash_map.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 #include "src/trace_processor/importers/common/args_tracker.h"
 #include "src/trace_processor/importers/common/deobfuscation_mapping_table.h"
@@ -86,23 +86,23 @@
     deobfuscation_mapping_table_ = std::move(deobfuscation_mapping_table);
   }
 
-  base::Optional<base::StringView> TranslateChromeHistogramHashForTesting(
+  std::optional<base::StringView> TranslateChromeHistogramHashForTesting(
       uint64_t hash) const {
     return TranslateChromeHistogramHash(hash);
   }
-  base::Optional<base::StringView> TranslateChromeUserEventHashForTesting(
+  std::optional<base::StringView> TranslateChromeUserEventHashForTesting(
       uint64_t hash) const {
     return TranslateChromeUserEventHash(hash);
   }
-  base::Optional<base::StringView>
+  std::optional<base::StringView>
   TranslateChromePerformanceMarkSiteHashForTesting(uint64_t hash) const {
     return TranslateChromePerformanceMarkSiteHash(hash);
   }
-  base::Optional<base::StringView>
+  std::optional<base::StringView>
   TranslateChromePerformanceMarkMarkHashForTesting(uint64_t hash) const {
     return TranslateChromePerformanceMarkMarkHash(hash);
   }
-  base::Optional<StringId> TranslateClassNameForTesting(
+  std::optional<StringId> TranslateClassNameForTesting(
       StringId obfuscated_class_name_id) const {
     return TranslateClassName(obfuscated_class_name_id);
   }
@@ -180,29 +180,30 @@
   DeobfuscationMappingTable deobfuscation_mapping_table_;
 
   // Returns the corresponding SupportedKey enum if the table knows how to
-  // translate the argument with the given key and type, and nullopt otherwise.
-  base::Optional<KeyType> KeyIdAndTypeToEnum(StringId flat_key_id,
-                                             StringId key_id,
-                                             Variadic::Type type) const;
+  // translate the argument with the given key and type, and std::nullopt
+  // otherwise.
+  std::optional<KeyType> KeyIdAndTypeToEnum(StringId flat_key_id,
+                                            StringId key_id,
+                                            Variadic::Type type) const;
 
-  base::Optional<base::StringView> TranslateChromeHistogramHash(
+  std::optional<base::StringView> TranslateChromeHistogramHash(
       uint64_t hash) const;
-  base::Optional<base::StringView> TranslateChromeUserEventHash(
+  std::optional<base::StringView> TranslateChromeUserEventHash(
       uint64_t hash) const;
-  base::Optional<base::StringView> TranslateChromePerformanceMarkSiteHash(
+  std::optional<base::StringView> TranslateChromePerformanceMarkSiteHash(
       uint64_t hash) const;
-  base::Optional<base::StringView> TranslateChromePerformanceMarkMarkHash(
+  std::optional<base::StringView> TranslateChromePerformanceMarkMarkHash(
       uint64_t hash) const;
-  base::Optional<SourceLocation> TranslateNativeSymbol(MappingId mapping_id,
-                                                       uint64_t rel_pc) const;
+  std::optional<SourceLocation> TranslateNativeSymbol(MappingId mapping_id,
+                                                      uint64_t rel_pc) const;
 
-  // Returns the deobfuscated name of a Java class or base::nullopt if
+  // Returns the deobfuscated name of a Java class or std::nullopt if
   // translation is not found.
-  base::Optional<StringId> TranslateClassName(
+  std::optional<StringId> TranslateClassName(
       StringId obfuscated_class_name_id) const;
 
-  void EmitMojoMethodLocation(base::Optional<uint64_t> mapping_id,
-                              base::Optional<uint64_t> rel_pc,
+  void EmitMojoMethodLocation(std::optional<uint64_t> mapping_id,
+                              std::optional<uint64_t> rel_pc,
                               ArgsTracker::BoundInserter& inserter) const;
 };
 
diff --git a/src/trace_processor/importers/common/args_translation_table_unittest.cc b/src/trace_processor/importers/common/args_translation_table_unittest.cc
index 904e607..e44b034 100644
--- a/src/trace_processor/importers/common/args_translation_table_unittest.cc
+++ b/src/trace_processor/importers/common/args_translation_table_unittest.cc
@@ -15,7 +15,9 @@
  */
 
 #include "src/trace_processor/importers/common/args_translation_table.h"
-#include "perfetto/ext/base/optional.h"
+
+#include <optional>
+
 #include "src/trace_processor/importers/common/deobfuscation_mapping_table.h"
 #include "test/gtest_and_gmock.h"
 
@@ -26,8 +28,8 @@
 TEST(ArgsTranslationTable, EmptyTableByDefault) {
   TraceStorage storage;
   ArgsTranslationTable table(&storage);
-  EXPECT_EQ(table.TranslateChromeHistogramHashForTesting(1), base::nullopt);
-  EXPECT_EQ(table.TranslateChromeUserEventHashForTesting(1), base::nullopt);
+  EXPECT_EQ(table.TranslateChromeHistogramHashForTesting(1), std::nullopt);
+  EXPECT_EQ(table.TranslateChromeUserEventHashForTesting(1), std::nullopt);
 }
 
 TEST(ArgsTranslationTable, TranslatesHistogramHashes) {
@@ -36,10 +38,10 @@
   table.AddChromeHistogramTranslationRule(1, "hash1");
   table.AddChromeHistogramTranslationRule(10, "hash2");
   EXPECT_EQ(table.TranslateChromeHistogramHashForTesting(1),
-            base::Optional<base::StringView>("hash1"));
+            std::optional<base::StringView>("hash1"));
   EXPECT_EQ(table.TranslateChromeHistogramHashForTesting(10),
-            base::Optional<base::StringView>("hash2"));
-  EXPECT_EQ(table.TranslateChromeHistogramHashForTesting(2), base::nullopt);
+            std::optional<base::StringView>("hash2"));
+  EXPECT_EQ(table.TranslateChromeHistogramHashForTesting(2), std::nullopt);
 }
 
 TEST(ArgsTranslationTable, TranslatesUserEventHashes) {
@@ -48,10 +50,10 @@
   table.AddChromeUserEventTranslationRule(1, "action1");
   table.AddChromeUserEventTranslationRule(10, "action2");
   EXPECT_EQ(table.TranslateChromeUserEventHashForTesting(1),
-            base::Optional<base::StringView>("action1"));
+            std::optional<base::StringView>("action1"));
   EXPECT_EQ(table.TranslateChromeUserEventHashForTesting(10),
-            base::Optional<base::StringView>("action2"));
-  EXPECT_EQ(table.TranslateChromeUserEventHashForTesting(2), base::nullopt);
+            std::optional<base::StringView>("action2"));
+  EXPECT_EQ(table.TranslateChromeUserEventHashForTesting(2), std::nullopt);
 }
 
 TEST(ArgsTranslationTable, TranslatesPerformanceMarkSiteHashes) {
@@ -60,11 +62,11 @@
   table.AddChromePerformanceMarkSiteTranslationRule(1, "hash1");
   table.AddChromePerformanceMarkSiteTranslationRule(10, "hash2");
   EXPECT_EQ(table.TranslateChromePerformanceMarkSiteHashForTesting(1),
-            base::Optional<base::StringView>("hash1"));
+            std::optional<base::StringView>("hash1"));
   EXPECT_EQ(table.TranslateChromePerformanceMarkSiteHashForTesting(10),
-            base::Optional<base::StringView>("hash2"));
+            std::optional<base::StringView>("hash2"));
   EXPECT_EQ(table.TranslateChromePerformanceMarkSiteHashForTesting(2),
-            base::nullopt);
+            std::nullopt);
 }
 
 TEST(ArgsTranslationTable, TranslatesPerformanceMarkMarkHashes) {
@@ -73,11 +75,11 @@
   table.AddChromePerformanceMarkMarkTranslationRule(1, "hash1");
   table.AddChromePerformanceMarkMarkTranslationRule(10, "hash2");
   EXPECT_EQ(table.TranslateChromePerformanceMarkMarkHashForTesting(1),
-            base::Optional<base::StringView>("hash1"));
+            std::optional<base::StringView>("hash1"));
   EXPECT_EQ(table.TranslateChromePerformanceMarkMarkHashForTesting(10),
-            base::Optional<base::StringView>("hash2"));
+            std::optional<base::StringView>("hash2"));
   EXPECT_EQ(table.TranslateChromePerformanceMarkMarkHashForTesting(2),
-            base::nullopt);
+            std::nullopt);
 }
 
 TEST(ArgsTranslationTable, TranslateClassName) {
@@ -93,8 +95,8 @@
   table.AddDeobfuscationMappingTable(std::move(deobfuscation_mapping));
 
   EXPECT_EQ(table.TranslateClassNameForTesting(xyz_id),
-            base::Optional<StringId>(class_x_id));
-  EXPECT_EQ(table.TranslateClassNameForTesting(abc_id), base::nullopt);
+            std::optional<StringId>(class_x_id));
+  EXPECT_EQ(table.TranslateClassNameForTesting(abc_id), std::nullopt);
 }
 
 TEST(ArgsTranslationTable, NeedsTranslation) {
diff --git a/src/trace_processor/importers/common/clock_tracker.h b/src/trace_processor/importers/common/clock_tracker.h
index 81588e6..a4edd3c 100644
--- a/src/trace_processor/importers/common/clock_tracker.h
+++ b/src/trace_processor/importers/common/clock_tracker.h
@@ -22,12 +22,12 @@
 #include <array>
 #include <cinttypes>
 #include <map>
+#include <optional>
 #include <random>
 #include <set>
 #include <vector>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/status_or.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "src/trace_processor/importers/common/metadata_tracker.h"
diff --git a/src/trace_processor/importers/common/clock_tracker_unittest.cc b/src/trace_processor/importers/common/clock_tracker_unittest.cc
index e625111..74a665f 100644
--- a/src/trace_processor/importers/common/clock_tracker_unittest.cc
+++ b/src/trace_processor/importers/common/clock_tracker_unittest.cc
@@ -16,9 +16,9 @@
 
 #include "src/trace_processor/importers/common/clock_tracker.h"
 
+#include <optional>
 #include <random>
 
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/importers/common/metadata_tracker.h"
 #include "src/trace_processor/storage/trace_storage.h"
 #include "src/trace_processor/types/trace_processor_context.h"
diff --git a/src/trace_processor/importers/common/deobfuscation_mapping_table.cc b/src/trace_processor/importers/common/deobfuscation_mapping_table.cc
index af5bbf3..243295b 100644
--- a/src/trace_processor/importers/common/deobfuscation_mapping_table.cc
+++ b/src/trace_processor/importers/common/deobfuscation_mapping_table.cc
@@ -39,50 +39,50 @@
       .second;
 }
 
-base::Optional<StringId> DeobfuscationMappingTable::TranslateClass(
+std::optional<StringId> DeobfuscationMappingTable::TranslateClass(
     StringId obfuscated_class_name) const {
   if (PERFETTO_UNLIKELY(!default_package_id_.has_value())) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return TranslateClass(default_package_id_.value(), obfuscated_class_name);
 }
 
-base::Optional<StringId> DeobfuscationMappingTable::TranslateClass(
+std::optional<StringId> DeobfuscationMappingTable::TranslateClass(
     const PackageId& package,
     StringId obfuscated_class_name) const {
   const ObfuscatedClassesToMembers* classes_translation_ptr =
       class_per_package_translation_.Find(package);
   if (classes_translation_ptr == nullptr) {
-    return base::nullopt;
+    return std::nullopt;
   }
   const ClassTranslation* class_translation_ptr =
       classes_translation_ptr->Find(obfuscated_class_name);
   if (class_translation_ptr == nullptr) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return class_translation_ptr->deobfuscated_class_name;
 }
 
-base::Optional<StringId> DeobfuscationMappingTable::TranslateMember(
+std::optional<StringId> DeobfuscationMappingTable::TranslateMember(
     const PackageId& package,
     StringId obfuscated_class_name,
     StringId obfuscated_member) const {
   const ObfuscatedClassesToMembers* classes_translation_ptr =
       class_per_package_translation_.Find(package);
   if (classes_translation_ptr == nullptr) {
-    return base::nullopt;
+    return std::nullopt;
   }
 
   const ClassTranslation* class_translation_ptr =
       classes_translation_ptr->Find(obfuscated_class_name);
   if (class_translation_ptr == nullptr) {
-    return base::nullopt;
+    return std::nullopt;
   }
 
   const StringId* member_translation_ptr =
       class_translation_ptr->members.Find(obfuscated_member);
   if (member_translation_ptr == nullptr) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return *member_translation_ptr;
 }
diff --git a/src/trace_processor/importers/common/deobfuscation_mapping_table.h b/src/trace_processor/importers/common/deobfuscation_mapping_table.h
index 7022b19..9beeab9 100644
--- a/src/trace_processor/importers/common/deobfuscation_mapping_table.h
+++ b/src/trace_processor/importers/common/deobfuscation_mapping_table.h
@@ -18,12 +18,12 @@
 #define SRC_TRACE_PROCESSOR_IMPORTERS_COMMON_DEOBFUSCATION_MAPPING_TABLE_H_
 
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "perfetto/ext/base/flat_hash_map.h"
 #include "perfetto/ext/base/hash.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 #include "src/trace_processor/storage/trace_storage.h"
 
@@ -58,16 +58,16 @@
   // These functions return the deobfuscated class/member name from an
   // obfuscated class/member name.
   // If a package is not provided, the |default_package_id_| is used.
-  // If translation is not found, returns base::nullopt.
+  // If translation is not found, returns std::nullopt.
 
-  base::Optional<StringId> TranslateClass(StringId obfuscated_class_name) const;
+  std::optional<StringId> TranslateClass(StringId obfuscated_class_name) const;
 
-  base::Optional<StringId> TranslateClass(const PackageId& package,
-                                          StringId obfuscated_class_name) const;
+  std::optional<StringId> TranslateClass(const PackageId& package,
+                                         StringId obfuscated_class_name) const;
 
-  base::Optional<StringId> TranslateMember(const PackageId& package,
-                                           StringId obfuscated_class_name,
-                                           StringId obfuscated_member) const;
+  std::optional<StringId> TranslateMember(const PackageId& package,
+                                          StringId obfuscated_class_name,
+                                          StringId obfuscated_member) const;
 
  private:
   struct PackageIdHash {
@@ -94,7 +94,7 @@
   // We need this because curently TraceProcessor doesn't use the package
   // version of the arguments.
   // TODO(b/244700870): start use the package version of arguments.
-  base::Optional<PackageId> default_package_id_;
+  std::optional<PackageId> default_package_id_;
 };
 
 }  // namespace trace_processor
diff --git a/src/trace_processor/importers/common/deobfuscation_mapping_table_unittest.cc b/src/trace_processor/importers/common/deobfuscation_mapping_table_unittest.cc
index 5b24492..d663db4 100644
--- a/src/trace_processor/importers/common/deobfuscation_mapping_table_unittest.cc
+++ b/src/trace_processor/importers/common/deobfuscation_mapping_table_unittest.cc
@@ -30,8 +30,8 @@
   StringId xyz_id = storage.InternString("xyz");
 
   DeobfuscationMappingTable table;
-  EXPECT_EQ(table.TranslateClass(xyz_id), base::nullopt);
-  EXPECT_EQ(table.TranslateClass(PackageId{"app", 123}, xyz_id), base::nullopt);
+  EXPECT_EQ(table.TranslateClass(xyz_id), std::nullopt);
+  EXPECT_EQ(table.TranslateClass(PackageId{"app", 123}, xyz_id), std::nullopt);
 }
 
 TEST(DeobfuscationMappingTable, TranslateClassSingleInsert) {
@@ -45,8 +45,8 @@
                             base::FlatHashMap<StringId, StringId>{});
   EXPECT_EQ(table.TranslateClass(xyz_id), class_x_id);
   EXPECT_EQ(table.TranslateClass(PackageId{"app", 123}, xyz_id), class_x_id);
-  EXPECT_EQ(table.TranslateClass(PackageId{"app", 124}, xyz_id), base::nullopt);
-  EXPECT_EQ(table.TranslateClass(PackageId{"app", 123}, abc_id), base::nullopt);
+  EXPECT_EQ(table.TranslateClass(PackageId{"app", 124}, xyz_id), std::nullopt);
+  EXPECT_EQ(table.TranslateClass(PackageId{"app", 123}, abc_id), std::nullopt);
 }
 
 TEST(DeobfuscationMappingTable, TranslateClassMultipleInsert) {
@@ -65,11 +65,10 @@
   table.AddClassTranslation(PackageId{"app3", 123}, abc_id, class_a_id,
                             base::FlatHashMap<StringId, StringId>{});
   EXPECT_EQ(table.TranslateClass(xyz_id), class_x_id);
-  EXPECT_EQ(table.TranslateClass(abc_id), base::nullopt);
+  EXPECT_EQ(table.TranslateClass(abc_id), std::nullopt);
   EXPECT_EQ(table.TranslateClass(PackageId{"app1", 123}, xyz_id), class_x_id);
   EXPECT_EQ(table.TranslateClass(PackageId{"app2", 123}, xyz_id), class_y_id);
-  EXPECT_EQ(table.TranslateClass(PackageId{"app1", 123}, abc_id),
-            base::nullopt);
+  EXPECT_EQ(table.TranslateClass(PackageId{"app1", 123}, abc_id), std::nullopt);
 }
 
 TEST(DeobfuscationMappingTable, TranslateMember) {
@@ -95,11 +94,11 @@
   EXPECT_EQ(table.TranslateMember(PackageId{"app1", 123}, xyz_id, mmm_2_id),
             member_2_id);
   EXPECT_EQ(table.TranslateMember(PackageId{"app1", 123}, xyz_id, mmm_4_id),
-            base::nullopt);
+            std::nullopt);
   EXPECT_EQ(table.TranslateMember(PackageId{"app1", 123}, abc_id, mmm_2_id),
-            base::nullopt);
+            std::nullopt);
   EXPECT_EQ(table.TranslateMember(PackageId{"app1", 124}, xyz_id, mmm_2_id),
-            base::nullopt);
+            std::nullopt);
 }
 
 }  // namespace
diff --git a/src/trace_processor/importers/common/event_tracker.cc b/src/trace_processor/importers/common/event_tracker.cc
index cf59e40..0ed799b 100644
--- a/src/trace_processor/importers/common/event_tracker.cc
+++ b/src/trace_processor/importers/common/event_tracker.cc
@@ -17,9 +17,9 @@
 #include "src/trace_processor/importers/common/event_tracker.h"
 
 #include <math.h>
+#include <optional>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/utils.h"
 #include "src/trace_processor/importers/common/args_tracker.h"
 #include "src/trace_processor/importers/common/process_tracker.h"
@@ -36,7 +36,7 @@
 
 EventTracker::~EventTracker() = default;
 
-base::Optional<CounterId> EventTracker::PushProcessCounterForThread(
+std::optional<CounterId> EventTracker::PushProcessCounterForThread(
     int64_t timestamp,
     double value,
     StringId name_id,
@@ -52,15 +52,15 @@
   return opt_id;
 }
 
-base::Optional<CounterId> EventTracker::PushCounter(int64_t timestamp,
-                                                    double value,
-                                                    TrackId track_id) {
+std::optional<CounterId> EventTracker::PushCounter(int64_t timestamp,
+                                                   double value,
+                                                   TrackId track_id) {
   if (timestamp < max_timestamp_) {
     PERFETTO_DLOG(
         "counter event (ts: %" PRId64 ") out of order by %.4f ms, skipping",
         timestamp, static_cast<double>(max_timestamp_ - timestamp) / 1e6);
     context_->storage->IncrementStats(stats::counter_events_out_of_order);
-    return base::nullopt;
+    return std::nullopt;
   }
   max_timestamp_ = timestamp;
 
@@ -68,7 +68,7 @@
   return counter_values->Insert({timestamp, track_id, value}).id;
 }
 
-base::Optional<CounterId> EventTracker::PushCounter(
+std::optional<CounterId> EventTracker::PushCounter(
     int64_t timestamp,
     double value,
     TrackId track_id,
@@ -85,7 +85,7 @@
   const auto& thread_table = context_->storage->thread_table();
   for (const auto& pending_counter : pending_upid_resolution_counter_) {
     UniqueTid utid = pending_counter.utid;
-    base::Optional<UniquePid> upid = thread_table.upid()[utid];
+    std::optional<UniquePid> upid = thread_table.upid()[utid];
 
     TrackId track_id = kInvalidTrackId;
     if (upid.has_value()) {
diff --git a/src/trace_processor/importers/common/event_tracker.h b/src/trace_processor/importers/common/event_tracker.h
index 16117f0..626e80e 100644
--- a/src/trace_processor/importers/common/event_tracker.h
+++ b/src/trace_processor/importers/common/event_tracker.h
@@ -42,16 +42,16 @@
 
   // Adds a counter event to the counters table returning the index of the
   // newly added row.
-  virtual base::Optional<CounterId> PushCounter(int64_t timestamp,
-                                                double value,
-                                                TrackId track_id);
+  virtual std::optional<CounterId> PushCounter(int64_t timestamp,
+                                               double value,
+                                               TrackId track_id);
 
   // Adds a counter event with args to the counters table returning the index of
   // the newly added row.
-  base::Optional<CounterId> PushCounter(int64_t timestamp,
-                                        double value,
-                                        TrackId track_id,
-                                        SetArgsCallback args_callback);
+  std::optional<CounterId> PushCounter(int64_t timestamp,
+                                       double value,
+                                       TrackId track_id,
+                                       SetArgsCallback args_callback);
 
   // Adds a counter event to the counters table for counter events which
   // should be associated with a process but only have a thread context
@@ -59,7 +59,7 @@
   //
   // This function will resolve the utid to a upid when the events are
   // flushed (see |FlushPendingEvents()|).
-  virtual base::Optional<CounterId> PushProcessCounterForThread(
+  virtual std::optional<CounterId> PushProcessCounterForThread(
       int64_t timestamp,
       double value,
       StringId name_id,
diff --git a/src/trace_processor/importers/common/flow_tracker.cc b/src/trace_processor/importers/common/flow_tracker.cc
index ff9f609..7805544 100644
--- a/src/trace_processor/importers/common/flow_tracker.cc
+++ b/src/trace_processor/importers/common/flow_tracker.cc
@@ -40,7 +40,7 @@
   it is a bit tricky to make it here.
   We suspect that this case is too rare or impossible */
 void FlowTracker::Begin(TrackId track_id, FlowId flow_id) {
-  base::Optional<SliceId> open_slice_id =
+  std::optional<SliceId> open_slice_id =
       context_->slice_tracker->GetTopmostSliceOnTrack(track_id);
   if (!open_slice_id) {
     context_->storage->IncrementStats(stats::flow_no_enclosing_slice);
@@ -58,7 +58,7 @@
 }
 
 void FlowTracker::Step(TrackId track_id, FlowId flow_id) {
-  base::Optional<SliceId> open_slice_id =
+  std::optional<SliceId> open_slice_id =
       context_->slice_tracker->GetTopmostSliceOnTrack(track_id);
   if (!open_slice_id) {
     context_->storage->IncrementStats(stats::flow_no_enclosing_slice);
@@ -86,7 +86,7 @@
     pending_flow_ids_map_[track_id].push_back(flow_id);
     return;
   }
-  base::Optional<SliceId> open_slice_id =
+  std::optional<SliceId> open_slice_id =
       context_->slice_tracker->GetTopmostSliceOnTrack(track_id);
   if (!open_slice_id) {
     context_->storage->IncrementStats(stats::flow_no_enclosing_slice);
diff --git a/src/trace_processor/importers/common/metadata_tracker.cc b/src/trace_processor/importers/common/metadata_tracker.cc
index 010b1b7..7468c42 100644
--- a/src/trace_processor/importers/common/metadata_tracker.cc
+++ b/src/trace_processor/importers/common/metadata_tracker.cc
@@ -52,7 +52,7 @@
 
   auto* metadata_table = storage_->mutable_metadata_table();
   uint32_t key_idx = static_cast<uint32_t>(key);
-  base::Optional<uint32_t> opt_row =
+  std::optional<uint32_t> opt_row =
       metadata_table->name().IndexOf(metadata::kNames[key_idx]);
   if (opt_row) {
     WriteValue(*opt_row, value);
diff --git a/src/trace_processor/importers/common/parser_types.h b/src/trace_processor/importers/common/parser_types.h
index e6575f1..2b5648a 100644
--- a/src/trace_processor/importers/common/parser_types.h
+++ b/src/trace_processor/importers/common/parser_types.h
@@ -68,8 +68,8 @@
   }
 
   TracePacketData trace_packet_data;
-  base::Optional<int64_t> thread_timestamp;
-  base::Optional<int64_t> thread_instruction_count;
+  std::optional<int64_t> thread_timestamp;
+  std::optional<int64_t> thread_instruction_count;
   double counter_value = 0;
   std::array<double, kMaxNumExtraCounters> extra_counter_values = {};
 };
diff --git a/src/trace_processor/importers/common/process_tracker.cc b/src/trace_processor/importers/common/process_tracker.cc
index df14d2c..473c48e 100644
--- a/src/trace_processor/importers/common/process_tracker.cc
+++ b/src/trace_processor/importers/common/process_tracker.cc
@@ -48,7 +48,7 @@
 
 ProcessTracker::~ProcessTracker() = default;
 
-UniqueTid ProcessTracker::StartNewThread(base::Optional<int64_t> timestamp,
+UniqueTid ProcessTracker::StartNewThread(std::optional<int64_t> timestamp,
                                          uint32_t tid) {
   tables::ThreadTable::Row row;
   row.tid = tid;
@@ -74,7 +74,7 @@
   // we would have already ended the process and we don't want to
   // create a new thread here (see b/193520421 for an example of a trace
   // where this happens in practice).
-  base::Optional<UniqueTid> opt_utid = GetThreadOrNull(tid);
+  std::optional<UniqueTid> opt_utid = GetThreadOrNull(tid);
   if (!opt_utid)
     return;
 
@@ -97,10 +97,10 @@
   pids_.Erase(tid);
 }
 
-base::Optional<UniqueTid> ProcessTracker::GetThreadOrNull(uint32_t tid) {
-  auto opt_utid = GetThreadOrNull(tid, base::nullopt);
+std::optional<UniqueTid> ProcessTracker::GetThreadOrNull(uint32_t tid) {
+  auto opt_utid = GetThreadOrNull(tid, std::nullopt);
   if (!opt_utid)
-    return base::nullopt;
+    return std::nullopt;
 
   auto* threads = context_->storage->mutable_thread_table();
   UniqueTid utid = *opt_utid;
@@ -117,7 +117,7 @@
 
 UniqueTid ProcessTracker::GetOrCreateThread(uint32_t tid) {
   auto utid = GetThreadOrNull(tid);
-  return utid ? *utid : StartNewThread(base::nullopt, tid);
+  return utid ? *utid : StartNewThread(std::nullopt, tid);
 }
 
 UniqueTid ProcessTracker::UpdateThreadName(uint32_t tid,
@@ -168,15 +168,15 @@
   return true;
 }
 
-base::Optional<UniqueTid> ProcessTracker::GetThreadOrNull(
+std::optional<UniqueTid> ProcessTracker::GetThreadOrNull(
     uint32_t tid,
-    base::Optional<uint32_t> pid) {
+    std::optional<uint32_t> pid) {
   auto* threads = context_->storage->mutable_thread_table();
   auto* processes = context_->storage->mutable_process_table();
 
   auto vector_it = tids_.Find(tid);
   if (!vector_it)
-    return base::nullopt;
+    return std::nullopt;
 
   // Iterate backwards through the threads so ones later in the trace are more
   // likely to be picked.
@@ -202,17 +202,17 @@
     if (!pid || current_pid == *pid)
       return current_utid;
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 UniqueTid ProcessTracker::UpdateThread(uint32_t tid, uint32_t pid) {
   auto* thread_table = context_->storage->mutable_thread_table();
 
   // Try looking for a thread that matches both tid and thread group id (pid).
-  base::Optional<UniqueTid> opt_utid = GetThreadOrNull(tid, pid);
+  std::optional<UniqueTid> opt_utid = GetThreadOrNull(tid, pid);
 
   // If no matching thread was found, create a new one.
-  UniqueTid utid = opt_utid ? *opt_utid : StartNewThread(base::nullopt, tid);
+  UniqueTid utid = opt_utid ? *opt_utid : StartNewThread(std::nullopt, tid);
   PERFETTO_DCHECK(thread_table->tid()[utid] == tid);
 
   // Find matching process or create new one.
@@ -229,23 +229,23 @@
   trusted_pids_[uuid] = trusted_pid;
 }
 
-base::Optional<uint32_t> ProcessTracker::GetTrustedPid(uint64_t uuid) {
+std::optional<uint32_t> ProcessTracker::GetTrustedPid(uint64_t uuid) {
   if (trusted_pids_.find(uuid) == trusted_pids_.end())
-    return base::nullopt;
+    return std::nullopt;
   return trusted_pids_[uuid];
 }
 
-base::Optional<uint32_t> ProcessTracker::ResolveNamespacedTid(
+std::optional<uint32_t> ProcessTracker::ResolveNamespacedTid(
     uint32_t root_level_pid,
     uint32_t tid) {
   if (root_level_pid <= 0)  // Not a valid pid.
-    return base::nullopt;
+    return std::nullopt;
 
   // If the process doesn't run in a namespace (or traced_probes doesn't observe
-  // that), return base::nullopt as failure to resolve.
+  // that), return std::nullopt as failure to resolve.
   auto process_it = namespaced_processes_.find(root_level_pid);
   if (process_it == namespaced_processes_.end())
-    return base::nullopt;
+    return std::nullopt;
 
   // Check if it's the main thread.
   const auto& process = process_it->second;
@@ -264,11 +264,11 @@
   }
 
   // Failed to resolve or the thread isn't namespaced
-  return base::nullopt;
+  return std::nullopt;
 }
 
-UniquePid ProcessTracker::StartNewProcess(base::Optional<int64_t> timestamp,
-                                          base::Optional<uint32_t> parent_tid,
+UniquePid ProcessTracker::StartNewProcess(std::optional<int64_t> timestamp,
+                                          std::optional<uint32_t> parent_tid,
                                           uint32_t pid,
                                           StringId main_thread_name,
                                           ThreadNamePriority priority) {
@@ -311,10 +311,10 @@
 }
 
 UniquePid ProcessTracker::SetProcessMetadata(uint32_t pid,
-                                             base::Optional<uint32_t> ppid,
+                                             std::optional<uint32_t> ppid,
                                              base::StringView name,
                                              base::StringView cmdline) {
-  base::Optional<UniquePid> pupid;
+  std::optional<UniquePid> pupid;
   if (ppid.has_value()) {
     pupid = GetOrCreateProcess(ppid.value());
   }
@@ -363,7 +363,7 @@
   auto* process_table = context_->storage->mutable_process_table();
 
   UniqueTid utid = UpdateThreadName(tid, thread_name, priority);
-  base::Optional<UniquePid> opt_upid = thread_table->upid()[utid];
+  std::optional<UniquePid> opt_upid = thread_table->upid()[utid];
   if (opt_upid.has_value() && process_table->pid()[*opt_upid] == tid) {
     PERFETTO_DCHECK(thread_table->is_main_thread()[utid]);
     process_table->mutable_name()->Set(*opt_upid, thread_name);
diff --git a/src/trace_processor/importers/common/process_tracker.h b/src/trace_processor/importers/common/process_tracker.h
index 37298a6..df648c2 100644
--- a/src/trace_processor/importers/common/process_tracker.h
+++ b/src/trace_processor/importers/common/process_tracker.h
@@ -62,7 +62,7 @@
 
   // Called when a task_newtask is observed. This force the tracker to start
   // a new UTID for the thread, which is needed for TID-recycling resolution.
-  UniqueTid StartNewThread(base::Optional<int64_t> timestamp, uint32_t tid);
+  UniqueTid StartNewThread(std::optional<int64_t> timestamp, uint32_t tid);
 
   // Returns whether a thread is considered alive by the process tracker.
   bool IsThreadAlive(UniqueTid utid);
@@ -71,8 +71,8 @@
   // end the thread lifetime for the utid associated with the given tid.
   void EndThread(int64_t timestamp, uint32_t tid);
 
-  // Returns the thread utid or base::nullopt if it doesn't exist.
-  base::Optional<UniqueTid> GetThreadOrNull(uint32_t tid);
+  // Returns the thread utid or std::nullopt if it doesn't exist.
+  std::optional<UniqueTid> GetThreadOrNull(uint32_t tid);
 
   // Returns the thread utid (or creates a new entry if not present)
   UniqueTid GetOrCreateThread(uint32_t tid);
@@ -97,23 +97,23 @@
   // Associates trusted_pid with track UUID.
   void UpdateTrustedPid(uint32_t trusted_pid, uint64_t uuid);
 
-  // Returns the trusted_pid associated with the track UUID, or base::nullopt if
+  // Returns the trusted_pid associated with the track UUID, or std::nullopt if
   // not found.
-  base::Optional<uint32_t> GetTrustedPid(uint64_t uuid);
+  std::optional<uint32_t> GetTrustedPid(uint64_t uuid);
 
   // Performs namespace-local to root-level resolution of thread or process id,
   // given tid (can be root-level or namespace-local, but we don't know
   // beforehand) and root-level pid/tgid that the thread belongs to.
   // Returns the root-level thread id for tid on successful resolution;
-  // otherwise, returns base::nullopt on resolution failure, or the thread of
+  // otherwise, returns std::nullopt on resolution failure, or the thread of
   // tid isn't running in a pid namespace.
-  base::Optional<uint32_t> ResolveNamespacedTid(uint32_t root_level_pid,
-                                                uint32_t tid);
+  std::optional<uint32_t> ResolveNamespacedTid(uint32_t root_level_pid,
+                                               uint32_t tid);
 
   // Called when a task_newtask without the CLONE_THREAD flag is observed.
   // This force the tracker to start both a new UTID and a new UPID.
-  UniquePid StartNewProcess(base::Optional<int64_t> timestamp,
-                            base::Optional<uint32_t> parent_tid,
+  UniquePid StartNewProcess(std::optional<int64_t> timestamp,
+                            std::optional<uint32_t> parent_tid,
                             uint32_t pid,
                             StringId main_thread_name,
                             ThreadNamePriority priority);
@@ -122,7 +122,7 @@
   // for that pid or assigns a new one.
   // Virtual for testing.
   virtual UniquePid SetProcessMetadata(uint32_t pid,
-                                       base::Optional<uint32_t> ppid,
+                                       std::optional<uint32_t> ppid,
                                        base::StringView name,
                                        base::StringView cmdline);
 
@@ -149,9 +149,9 @@
   virtual UniquePid GetOrCreateProcess(uint32_t pid);
 
   // Returns the upid for a given pid.
-  base::Optional<UniquePid> UpidForPidForTesting(uint32_t pid) {
+  std::optional<UniquePid> UpidForPidForTesting(uint32_t pid) {
     auto it = pids_.Find(pid);
-    return it ? base::make_optional(*it) : base::nullopt;
+    return it ? std::make_optional(*it) : std::nullopt;
   }
 
   // Returns the bounds of a range that includes all UniqueTids that have the
@@ -191,10 +191,10 @@
 
  private:
   // Returns the utid of a thread having |tid| and |pid| as the parent process.
-  // pid == base::nullopt matches all processes.
-  // Returns base::nullopt if such a thread doesn't exist.
-  base::Optional<uint32_t> GetThreadOrNull(uint32_t tid,
-                                           base::Optional<uint32_t> pid);
+  // pid == std::nullopt matches all processes.
+  // Returns std::nullopt if such a thread doesn't exist.
+  std::optional<uint32_t> GetThreadOrNull(uint32_t tid,
+                                          std::optional<uint32_t> pid);
 
   // Called whenever we discover that the passed thread belongs to the passed
   // process. The |pending_assocs_| vector is scanned to see if there are any
diff --git a/src/trace_processor/importers/common/process_tracker_unittest.cc b/src/trace_processor/importers/common/process_tracker_unittest.cc
index de4102e..e4f06ce 100644
--- a/src/trace_processor/importers/common/process_tracker_unittest.cc
+++ b/src/trace_processor/importers/common/process_tracker_unittest.cc
@@ -16,8 +16,9 @@
 
 #include "src/trace_processor/importers/common/process_tracker.h"
 
+#include <optional>
+
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/importers/common/args_tracker.h"
 #include "src/trace_processor/importers/common/event_tracker.h"
 #include "test/gtest_and_gmock.h"
@@ -46,7 +47,7 @@
 };
 
 TEST_F(ProcessTrackerTest, PushProcess) {
-  context.process_tracker->SetProcessMetadata(1, base::nullopt, "test",
+  context.process_tracker->SetProcessMetadata(1, std::nullopt, "test",
                                               base::StringView());
   auto opt_upid = context.process_tracker->UpidForPidForTesting(1);
   ASSERT_EQ(opt_upid.value_or(-1), 1u);
@@ -65,18 +66,18 @@
 }
 
 TEST_F(ProcessTrackerTest, PushTwoProcessEntries_SamePidAndName) {
-  context.process_tracker->SetProcessMetadata(1, base::nullopt, "test",
+  context.process_tracker->SetProcessMetadata(1, std::nullopt, "test",
                                               base::StringView());
-  context.process_tracker->SetProcessMetadata(1, base::nullopt, "test",
+  context.process_tracker->SetProcessMetadata(1, std::nullopt, "test",
                                               base::StringView());
   auto opt_upid = context.process_tracker->UpidForPidForTesting(1);
   ASSERT_EQ(opt_upid.value_or(-1), 1u);
 }
 
 TEST_F(ProcessTrackerTest, PushTwoProcessEntries_DifferentPid) {
-  context.process_tracker->SetProcessMetadata(1, base::nullopt, "test",
+  context.process_tracker->SetProcessMetadata(1, std::nullopt, "test",
                                               base::StringView());
-  context.process_tracker->SetProcessMetadata(3, base::nullopt, "test",
+  context.process_tracker->SetProcessMetadata(3, std::nullopt, "test",
                                               base::StringView());
   auto opt_upid = context.process_tracker->UpidForPidForTesting(1);
   ASSERT_EQ(opt_upid.value_or(-1), 1u);
@@ -85,7 +86,7 @@
 }
 
 TEST_F(ProcessTrackerTest, AddProcessEntry_CorrectName) {
-  context.process_tracker->SetProcessMetadata(1, base::nullopt, "test",
+  context.process_tracker->SetProcessMetadata(1, std::nullopt, "test",
                                               base::StringView());
   auto name = context.storage->process_table().name().GetString(1);
 
@@ -108,12 +109,12 @@
 
 TEST_F(ProcessTrackerTest, PidReuseWithoutStartAndEndThread) {
   UniquePid p1 = context.process_tracker->StartNewProcess(
-      base::nullopt, base::nullopt, /*pid=*/1, kNullStringId,
+      std::nullopt, std::nullopt, /*pid=*/1, kNullStringId,
       ThreadNamePriority::kFtrace);
   UniqueTid t1 = context.process_tracker->UpdateThread(/*tid=*/2, /*pid=*/1);
 
   UniquePid p2 = context.process_tracker->StartNewProcess(
-      base::nullopt, base::nullopt, /*pid=*/1, kNullStringId,
+      std::nullopt, std::nullopt, /*pid=*/1, kNullStringId,
       ThreadNamePriority::kFtrace);
   UniqueTid t2 = context.process_tracker->UpdateThread(/*tid=*/2, /*pid=*/1);
 
@@ -128,7 +129,7 @@
 
 TEST_F(ProcessTrackerTest, Cmdline) {
   UniquePid upid = context.process_tracker->SetProcessMetadata(
-      1, base::nullopt, "test", "cmdline blah");
+      1, std::nullopt, "test", "cmdline blah");
   ASSERT_EQ(context.storage->process_table().cmdline().GetString(upid),
             "cmdline blah");
 }
@@ -158,7 +159,7 @@
 
 TEST_F(ProcessTrackerTest, SetStartTsIfUnset) {
   auto upid = context.process_tracker->StartNewProcess(
-      /*timestamp=*/base::nullopt, 0u, 123, kNullStringId,
+      /*timestamp=*/std::nullopt, 0u, 123, kNullStringId,
       ThreadNamePriority::kFtrace);
   context.process_tracker->SetStartTsIfUnset(upid, 1000);
   ASSERT_EQ(context.storage->process_table().start_ts()[upid], 1000);
@@ -188,7 +189,7 @@
 
 TEST_F(ProcessTrackerTest, EndThreadAfterProcessEnd) {
   context.process_tracker->StartNewProcess(
-      100, base::nullopt, 123, kNullStringId, ThreadNamePriority::kFtrace);
+      100, std::nullopt, 123, kNullStringId, ThreadNamePriority::kFtrace);
   context.process_tracker->UpdateThread(124, 123);
 
   context.process_tracker->EndThread(200, 123);
@@ -237,7 +238,7 @@
 
   // Don't resolve if the process/thread isn't namespaced.
   ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(2001, 2002),
-            base::nullopt);
+            std::nullopt);
 
   // Resolve from namespace-local PID to root-level PID.
   ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(1001, 1).value(),
diff --git a/src/trace_processor/importers/common/slice_tracker.cc b/src/trace_processor/importers/common/slice_tracker.cc
index 9f93fac..5f3af01 100644
--- a/src/trace_processor/importers/common/slice_tracker.cc
+++ b/src/trace_processor/importers/common/slice_tracker.cc
@@ -38,11 +38,11 @@
 
 SliceTracker::~SliceTracker() = default;
 
-base::Optional<SliceId> SliceTracker::Begin(int64_t timestamp,
-                                            TrackId track_id,
-                                            StringId category,
-                                            StringId raw_name,
-                                            SetArgsCallback args_callback) {
+std::optional<SliceId> SliceTracker::Begin(int64_t timestamp,
+                                           TrackId track_id,
+                                           StringId category,
+                                           StringId raw_name,
+                                           SetArgsCallback args_callback) {
   const StringId name =
       context_->slice_translation_table->TranslateName(raw_name);
   tables::SliceTable::Row row(timestamp, kPendingDuration, track_id, category,
@@ -77,12 +77,12 @@
   });
 }
 
-base::Optional<SliceId> SliceTracker::Scoped(int64_t timestamp,
-                                             TrackId track_id,
-                                             StringId category,
-                                             StringId raw_name,
-                                             int64_t duration,
-                                             SetArgsCallback args_callback) {
+std::optional<SliceId> SliceTracker::Scoped(int64_t timestamp,
+                                            TrackId track_id,
+                                            StringId category,
+                                            StringId raw_name,
+                                            int64_t duration,
+                                            SetArgsCallback args_callback) {
   PERFETTO_DCHECK(duration >= 0);
 
   const StringId name =
@@ -93,11 +93,11 @@
   });
 }
 
-base::Optional<SliceId> SliceTracker::End(int64_t timestamp,
-                                          TrackId track_id,
-                                          StringId category,
-                                          StringId raw_name,
-                                          SetArgsCallback args_callback) {
+std::optional<SliceId> SliceTracker::End(int64_t timestamp,
+                                         TrackId track_id,
+                                         StringId category,
+                                         StringId raw_name,
+                                         SetArgsCallback args_callback) {
   const StringId name =
       context_->slice_translation_table->TranslateName(raw_name);
   auto finder = [this, category, name](const SlicesStack& stack) {
@@ -106,23 +106,23 @@
   return CompleteSlice(timestamp, track_id, args_callback, finder);
 }
 
-base::Optional<uint32_t> SliceTracker::AddArgs(TrackId track_id,
-                                               StringId category,
-                                               StringId name,
-                                               SetArgsCallback args_callback) {
+std::optional<uint32_t> SliceTracker::AddArgs(TrackId track_id,
+                                              StringId category,
+                                              StringId name,
+                                              SetArgsCallback args_callback) {
   auto* it = stacks_.Find(track_id);
   if (!it)
-    return base::nullopt;
+    return std::nullopt;
 
   auto& stack = it->slice_stack;
   if (stack.empty())
-    return base::nullopt;
+    return std::nullopt;
 
   auto* slices = context_->storage->mutable_slice_table();
-  base::Optional<uint32_t> stack_idx =
+  std::optional<uint32_t> stack_idx =
       MatchingIncompleteSliceIndex(stack, name, category);
   if (!stack_idx.has_value())
-    return base::nullopt;
+    return std::nullopt;
 
   tables::SliceTable::RowNumber num = stack[*stack_idx].row;
   tables::SliceTable::RowReference ref = num.ToRowReference(slices);
@@ -135,7 +135,7 @@
   return num.row_number();
 }
 
-base::Optional<SliceId> SliceTracker::StartSlice(
+std::optional<SliceId> SliceTracker::StartSlice(
     int64_t timestamp,
     TrackId track_id,
     SetArgsCallback args_callback,
@@ -143,7 +143,7 @@
   // At this stage all events should be globally timestamp ordered.
   if (timestamp < prev_timestamp_) {
     context_->storage->IncrementStats(stats::slice_out_of_order);
-    return base::nullopt;
+    return std::nullopt;
   }
   prev_timestamp_ = timestamp;
 
@@ -159,7 +159,7 @@
     // If this is an unnestable track, don't start a new slice if one already
     // exists.
     if (!stack.empty()) {
-      return base::nullopt;
+      return std::nullopt;
     }
   }
 
@@ -168,12 +168,12 @@
 
   size_t depth = stack.size();
 
-  base::Optional<tables::SliceTable::RowReference> parent_ref =
-      depth == 0 ? base::nullopt
-                 : base::make_optional(stack.back().row.ToRowReference(slices));
+  std::optional<tables::SliceTable::RowReference> parent_ref =
+      depth == 0 ? std::nullopt
+                 : std::make_optional(stack.back().row.ToRowReference(slices));
   int64_t parent_stack_id = parent_ref ? parent_ref->stack_id() : 0;
-  base::Optional<tables::SliceTable::Id> parent_id =
-      parent_ref ? base::make_optional(parent_ref->id()) : base::nullopt;
+  std::optional<tables::SliceTable::Id> parent_id =
+      parent_ref ? std::make_optional(parent_ref->id()) : std::nullopt;
 
   SliceId id = inserter();
   tables::SliceTable::RowReference ref = *slices->FindById(id);
@@ -185,7 +185,7 @@
     PERFETTO_DLOG("Last slice: %s", parent_name.c_str());
     PERFETTO_DLOG("Current slice: %s", name.c_str());
     PERFETTO_DFATAL("Slices with too large depth found.");
-    return base::nullopt;
+    return std::nullopt;
   }
   StackPush(track_id, ref);
 
@@ -204,35 +204,35 @@
   return id;
 }
 
-base::Optional<SliceId> SliceTracker::CompleteSlice(
+std::optional<SliceId> SliceTracker::CompleteSlice(
     int64_t timestamp,
     TrackId track_id,
     SetArgsCallback args_callback,
-    std::function<base::Optional<uint32_t>(const SlicesStack&)> finder) {
+    std::function<std::optional<uint32_t>(const SlicesStack&)> finder) {
   // At this stage all events should be globally timestamp ordered.
   if (timestamp < prev_timestamp_) {
     context_->storage->IncrementStats(stats::slice_out_of_order);
-    return base::nullopt;
+    return std::nullopt;
   }
   prev_timestamp_ = timestamp;
 
   auto it = stacks_.Find(track_id);
   if (!it)
-    return base::nullopt;
+    return std::nullopt;
 
   TrackInfo& track_info = *it;
   SlicesStack& stack = track_info.slice_stack;
   MaybeCloseStack(timestamp, stack, track_id);
   if (stack.empty())
-    return base::nullopt;
+    return std::nullopt;
 
   auto* slices = context_->storage->mutable_slice_table();
-  base::Optional<uint32_t> stack_idx = finder(stack);
+  std::optional<uint32_t> stack_idx = finder(stack);
 
   // If we are trying to close slices that are not open on the stack (e.g.,
   // slices that began before tracing started), bail out.
   if (!stack_idx)
-    return base::nullopt;
+    return std::nullopt;
 
   const auto& slice_info = stack[stack_idx.value()];
 
@@ -266,8 +266,8 @@
 
 // Returns the first incomplete slice in the stack with matching name and
 // category. We assume null category/name matches everything. Returns
-// nullopt if no matching slice is found.
-base::Optional<uint32_t> SliceTracker::MatchingIncompleteSliceIndex(
+// std::nullopt if no matching slice is found.
+std::optional<uint32_t> SliceTracker::MatchingIncompleteSliceIndex(
     const SlicesStack& stack,
     StringId name,
     StringId category) {
@@ -277,19 +277,19 @@
         stack[static_cast<size_t>(i)].row.ToRowReference(slices);
     if (ref.dur() != kPendingDuration)
       continue;
-    base::Optional<StringId> other_category = ref.category();
+    std::optional<StringId> other_category = ref.category();
     if (!category.is_null() && (!other_category || other_category->is_null() ||
                                 category != other_category)) {
       continue;
     }
-    base::Optional<StringId> other_name = ref.name();
+    std::optional<StringId> other_name = ref.name();
     if (!name.is_null() && other_name && !other_name->is_null() &&
         name != other_name) {
       continue;
     }
     return static_cast<uint32_t>(i);
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 void SliceTracker::MaybeAddTranslatableArgs(SliceInfo& slice_info) {
@@ -339,14 +339,14 @@
   on_slice_begin_callback_ = callback;
 }
 
-base::Optional<SliceId> SliceTracker::GetTopmostSliceOnTrack(
+std::optional<SliceId> SliceTracker::GetTopmostSliceOnTrack(
     TrackId track_id) const {
   const auto* iter = stacks_.Find(track_id);
   if (!iter)
-    return base::nullopt;
+    return std::nullopt;
   const auto& stack = iter->slice_stack;
   if (stack.empty())
-    return base::nullopt;
+    return std::nullopt;
   const auto& slice = context_->storage->slice_table();
   return stack.back().row.ToRowReference(slice).id();
 }
diff --git a/src/trace_processor/importers/common/slice_tracker.h b/src/trace_processor/importers/common/slice_tracker.h
index b2bdebd..f0f59da 100644
--- a/src/trace_processor/importers/common/slice_tracker.h
+++ b/src/trace_processor/importers/common/slice_tracker.h
@@ -39,7 +39,7 @@
   virtual ~SliceTracker();
 
   // virtual for testing
-  virtual base::Optional<SliceId> Begin(
+  virtual std::optional<SliceId> Begin(
       int64_t timestamp,
       TrackId track_id,
       StringId category,
@@ -56,7 +56,7 @@
                              SetArgsCallback args_callback);
 
   template <typename Table>
-  base::Optional<SliceId> BeginTyped(
+  std::optional<SliceId> BeginTyped(
       Table* table,
       typename Table::Row row,
       SetArgsCallback args_callback = SetArgsCallback()) {
@@ -70,7 +70,7 @@
   }
 
   // virtual for testing
-  virtual base::Optional<SliceId> Scoped(
+  virtual std::optional<SliceId> Scoped(
       int64_t timestamp,
       TrackId track_id,
       StringId category,
@@ -79,7 +79,7 @@
       SetArgsCallback args_callback = SetArgsCallback());
 
   template <typename Table>
-  base::Optional<SliceId> ScopedTyped(
+  std::optional<SliceId> ScopedTyped(
       Table* table,
       typename Table::Row row,
       SetArgsCallback args_callback = SetArgsCallback()) {
@@ -92,7 +92,7 @@
   }
 
   // virtual for testing
-  virtual base::Optional<SliceId> End(
+  virtual std::optional<SliceId> End(
       int64_t timestamp,
       TrackId track_id,
       StringId opt_category = {},
@@ -102,16 +102,16 @@
   // Usually args should be added in the Begin or End args_callback but this
   // method is for the situation where new args need to be added to an
   // in-progress slice.
-  base::Optional<uint32_t> AddArgs(TrackId track_id,
-                                   StringId category,
-                                   StringId name,
-                                   SetArgsCallback args_callback);
+  std::optional<uint32_t> AddArgs(TrackId track_id,
+                                  StringId category,
+                                  StringId name,
+                                  SetArgsCallback args_callback);
 
   void FlushPendingSlices();
 
   void SetOnSliceBeginCallback(OnSliceBeginCallback callback);
 
-  base::Optional<SliceId> GetTopmostSliceOnTrack(TrackId track_id) const;
+  std::optional<SliceId> GetTopmostSliceOnTrack(TrackId track_id) const;
 
  private:
   // Slices which have been opened but haven't been closed yet will be marked
@@ -141,23 +141,22 @@
   };
 
   // virtual for testing.
-  virtual base::Optional<SliceId> StartSlice(int64_t timestamp,
-                                             TrackId track_id,
-                                             SetArgsCallback args_callback,
-                                             std::function<SliceId()> inserter);
+  virtual std::optional<SliceId> StartSlice(int64_t timestamp,
+                                            TrackId track_id,
+                                            SetArgsCallback args_callback,
+                                            std::function<SliceId()> inserter);
 
-  base::Optional<SliceId> CompleteSlice(
+  std::optional<SliceId> CompleteSlice(
       int64_t timestamp,
       TrackId track_id,
       SetArgsCallback args_callback,
-      std::function<base::Optional<uint32_t>(const SlicesStack&)> finder);
+      std::function<std::optional<uint32_t>(const SlicesStack&)> finder);
 
   void MaybeCloseStack(int64_t end_ts, const SlicesStack&, TrackId track_id);
 
-  base::Optional<uint32_t> MatchingIncompleteSliceIndex(
-      const SlicesStack& stack,
-      StringId name,
-      StringId category);
+  std::optional<uint32_t> MatchingIncompleteSliceIndex(const SlicesStack& stack,
+                                                       StringId name,
+                                                       StringId category);
 
   int64_t GetStackHash(const SlicesStack&);
 
diff --git a/src/trace_processor/importers/common/slice_tracker_unittest.cc b/src/trace_processor/importers/common/slice_tracker_unittest.cc
index 5b8d37d..ab214eb 100644
--- a/src/trace_processor/importers/common/slice_tracker_unittest.cc
+++ b/src/trace_processor/importers/common/slice_tracker_unittest.cc
@@ -322,7 +322,7 @@
   SliceId parent = context.storage->slice_table().id()[0];
   SliceId child = context.storage->slice_table().id()[1];
   EXPECT_THAT(context.storage->slice_table().parent_id().ToVectorForTesting(),
-              ElementsAre(base::nullopt, parent, child));
+              ElementsAre(std::nullopt, parent, child));
 }
 
 TEST(SliceTrackerTest, IgnoreMismatchedEnds) {
@@ -460,7 +460,7 @@
   TrackId track{1u};
   TrackId track2{2u};
 
-  EXPECT_EQ(tracker.GetTopmostSliceOnTrack(track), base::nullopt);
+  EXPECT_EQ(tracker.GetTopmostSliceOnTrack(track), std::nullopt);
 
   tracker.Begin(100, track, StringId::Raw(11), StringId::Raw(11));
   SliceId slice1 = context.storage->slice_table().id()[0];
@@ -472,7 +472,7 @@
 
   EXPECT_EQ(tracker.GetTopmostSliceOnTrack(track).value(), slice2);
 
-  EXPECT_EQ(tracker.GetTopmostSliceOnTrack(track2), base::nullopt);
+  EXPECT_EQ(tracker.GetTopmostSliceOnTrack(track2), std::nullopt);
 
   tracker.End(140, track, StringId::Raw(22), StringId::Raw(22));
 
@@ -480,7 +480,7 @@
 
   tracker.End(330, track, StringId::Raw(11), StringId::Raw(11));
 
-  EXPECT_EQ(tracker.GetTopmostSliceOnTrack(track), base::nullopt);
+  EXPECT_EQ(tracker.GetTopmostSliceOnTrack(track), std::nullopt);
 }
 
 TEST(SliceTrackerTest, OnSliceBeginCallback) {
diff --git a/src/trace_processor/importers/common/system_info_tracker.cc b/src/trace_processor/importers/common/system_info_tracker.cc
index f8c1007..89f0baf 100644
--- a/src/trace_processor/importers/common/system_info_tracker.cc
+++ b/src/trace_processor/importers/common/system_info_tracker.cc
@@ -26,7 +26,7 @@
 void SystemInfoTracker::SetKernelVersion(base::StringView name,
                                          base::StringView release) {
   if (name.empty() || release.empty() || name != "Linux") {
-    version_ = base::nullopt;
+    version_ = std::nullopt;
     return;
   }
 
diff --git a/src/trace_processor/importers/common/system_info_tracker.h b/src/trace_processor/importers/common/system_info_tracker.h
index af108c5..d9544d1 100644
--- a/src/trace_processor/importers/common/system_info_tracker.h
+++ b/src/trace_processor/importers/common/system_info_tracker.h
@@ -17,7 +17,8 @@
 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_COMMON_SYSTEM_INFO_TRACKER_H_
 #define SRC_TRACE_PROCESSOR_IMPORTERS_COMMON_SYSTEM_INFO_TRACKER_H_
 
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "perfetto/ext/base/string_view.h"
 #include "src/trace_processor/types/destructible.h"
 #include "src/trace_processor/types/trace_processor_context.h"
@@ -42,12 +43,12 @@
 
   void SetKernelVersion(base::StringView name, base::StringView release);
 
-  base::Optional<VersionNumber> GetKernelVersion() { return version_; }
+  std::optional<VersionNumber> GetKernelVersion() { return version_; }
 
  private:
   explicit SystemInfoTracker();
 
-  base::Optional<VersionNumber> version_;
+  std::optional<VersionNumber> version_;
 };
 }  // namespace trace_processor
 }  // namespace perfetto
diff --git a/src/trace_processor/importers/common/track_tracker.h b/src/trace_processor/importers/common/track_tracker.h
index f172148..c4a4232 100644
--- a/src/trace_processor/importers/common/track_tracker.h
+++ b/src/trace_processor/importers/common/track_tracker.h
@@ -145,7 +145,7 @@
     }
   };
   struct ChromeTrackTuple {
-    base::Optional<int64_t> upid;
+    std::optional<int64_t> upid;
     int64_t source_id = 0;
     StringId source_scope = StringId::Null();
 
@@ -178,8 +178,8 @@
   std::map<std::pair<StringId, int32_t>, TrackId>
       energy_per_uid_counter_tracks_;
 
-  base::Optional<TrackId> chrome_global_instant_track_id_;
-  base::Optional<TrackId> trigger_track_id_;
+  std::optional<TrackId> chrome_global_instant_track_id_;
+  std::optional<TrackId> trigger_track_id_;
 
   const StringId source_key_ = kNullStringId;
   const StringId source_id_key_ = kNullStringId;
diff --git a/src/trace_processor/importers/ftrace/binder_tracker.cc b/src/trace_processor/importers/ftrace/binder_tracker.cc
index 5e95579..7133c1f 100644
--- a/src/trace_processor/importers/ftrace/binder_tracker.cc
+++ b/src/trace_processor/importers/ftrace/binder_tracker.cc
@@ -170,7 +170,7 @@
     return;
   }
 
-  base::Optional<SliceId> recv_slice_id;
+  std::optional<SliceId> recv_slice_id;
   if (transaction.is_oneway) {
     recv_slice_id = context_->slice_tracker->Scoped(
         ts, track_id, binder_category_id_, async_rcv_id_, 0,
diff --git a/src/trace_processor/importers/ftrace/binder_tracker.h b/src/trace_processor/importers/ftrace/binder_tracker.h
index aa710e3..b17990a 100644
--- a/src/trace_processor/importers/ftrace/binder_tracker.h
+++ b/src/trace_processor/importers/ftrace/binder_tracker.h
@@ -18,10 +18,10 @@
 #define SRC_TRACE_PROCESSOR_IMPORTERS_FTRACE_BINDER_TRACKER_H_
 
 #include <stdint.h>
+#include <optional>
 
 #include "perfetto/base/flat_set.h"
 #include "perfetto/ext/base/flat_hash_map.h"
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/importers/common/args_tracker.h"
 #include "src/trace_processor/storage/trace_storage.h"
 #include "src/trace_processor/types/destructible.h"
@@ -72,8 +72,8 @@
     bool is_reply = false;
     bool is_oneway = false;
     SetArgsCallback args_inserter;
-    base::Optional<TrackId> send_track_id;
-    base::Optional<SliceId> send_slice_id;
+    std::optional<TrackId> send_track_id;
+    std::optional<SliceId> send_slice_id;
   };
 
   TraceProcessorContext* const context_;
diff --git a/src/trace_processor/importers/ftrace/drm_tracker.cc b/src/trace_processor/importers/ftrace/drm_tracker.cc
index ebe5b31..003b827 100644
--- a/src/trace_processor/importers/ftrace/drm_tracker.cc
+++ b/src/trace_processor/importers/ftrace/drm_tracker.cc
@@ -184,7 +184,7 @@
     inserter->AddArg(sched_arg_job_id_, Variadic::UnsignedInteger(job_id));
   };
 
-  base::Optional<SliceId> slice_id =
+  std::optional<SliceId> slice_id =
       context_->slice_tracker->Begin(timestamp, ring.track_id, kNullStringId,
                                      sched_slice_job_id_, args_inserter);
 
@@ -210,7 +210,7 @@
     inserter->AddArg(sched_arg_job_id_, Variadic::UnsignedInteger(job_id));
   };
 
-  base::Optional<SliceId> slice_id = context_->slice_tracker->Scoped(
+  std::optional<SliceId> slice_id = context_->slice_tracker->Scoped(
       timestamp, track_id, kNullStringId, sched_slice_schedule_id_, 0,
       args_inserter);
 
diff --git a/src/trace_processor/importers/ftrace/ftrace_parser.cc b/src/trace_processor/importers/ftrace/ftrace_parser.cc
index 78157d1..29af4bc 100644
--- a/src/trace_processor/importers/ftrace/ftrace_parser.cc
+++ b/src/trace_processor/importers/ftrace/ftrace_parser.cc
@@ -1079,7 +1079,7 @@
               ? metadata::all_data_source_started_ns
               : metadata::tracing_started_ns;
       const auto& metadata = context_->storage->metadata_table();
-      base::Optional<uint32_t> opt_row =
+      std::optional<uint32_t> opt_row =
           metadata.name().IndexOf(metadata::kNames[event_key]);
       if (opt_row) {
         drop_ftrace_data_before_ts_ = *metadata.int_value()[*opt_row];
@@ -1304,7 +1304,7 @@
   // [wr][atrace_slice..]
   // ...............[wri]
   //
-  base::Optional<UniqueTid> opt_utid =
+  std::optional<UniqueTid> opt_utid =
       context_->process_tracker->GetThreadOrNull(pid);
   if (opt_utid) {
     SyscallTracker::GetOrCreate(context_)->MaybeTruncateOngoingWriteSlice(
@@ -1842,7 +1842,7 @@
 }
 
 void FtraceParser::ParseCmaAllocStart(int64_t timestamp, uint32_t pid) {
-  base::Optional<VersionNumber> kernel_version =
+  std::optional<VersionNumber> kernel_version =
       SystemInfoTracker::GetOrCreate(context_)->GetKernelVersion();
   // CmaAllocInfo event only exists after 5.10
   if (kernel_version < VersionNumber{5, 10})
@@ -1858,7 +1858,7 @@
 void FtraceParser::ParseCmaAllocInfo(int64_t timestamp,
                                      uint32_t pid,
                                      ConstBytes blob) {
-  base::Optional<VersionNumber> kernel_version =
+  std::optional<VersionNumber> kernel_version =
       SystemInfoTracker::GetOrCreate(context_)->GetKernelVersion();
   // CmaAllocInfo event only exists after 5.10
   if (kernel_version < VersionNumber{5, 10})
@@ -2098,7 +2098,7 @@
     // the event as otherwise we would create fake processes which we
     // definitely want to avoid.
     // See b/192274404 for more info.
-    base::Optional<UniqueTid> opt_utid =
+    std::optional<UniqueTid> opt_utid =
         context_->process_tracker->GetThreadOrNull(pid);
     if (!opt_utid)
       return;
@@ -2156,7 +2156,7 @@
       protos::pbzero::InternedData::kKernelSymbolsFieldNumber,
       protos::pbzero::InternedString>(caller_iid);
 
-  base::Optional<StringId> blocked_function_str_id = base::nullopt;
+  std::optional<StringId> blocked_function_str_id = std::nullopt;
   if (interned_string) {
     protozero::ConstBytes str = interned_string->str();
     blocked_function_str_id = context_->storage->InternString(
@@ -2226,7 +2226,7 @@
 
   uint64_t nic_received_kilobytes = nic_received_bytes_[name] / 1024;
   TrackId track = context_->track_tracker->InternGlobalCounterTrack(name);
-  base::Optional<CounterId> id = context_->event_tracker->PushCounter(
+  std::optional<CounterId> id = context_->event_tracker->PushCounter(
       timestamp, static_cast<double>(nic_received_kilobytes), track);
   if (!id) {
     return;
@@ -2257,7 +2257,7 @@
 
   uint64_t nic_transmitted_kilobytes = nic_transmitted_bytes_[name] / 1024;
   TrackId track = context_->track_tracker->InternGlobalCounterTrack(name);
-  base::Optional<CounterId> id = context_->event_tracker->PushCounter(
+  std::optional<CounterId> id = context_->event_tracker->PushCounter(
       timestamp, static_cast<double>(nic_transmitted_kilobytes), track);
   if (!id) {
     return;
@@ -2416,7 +2416,7 @@
 
   TrackId track =
       context_->track_tracker->InternGlobalCounterTrack(kfree_skb_name_id_);
-  base::Optional<CounterId> id = context_->event_tracker->PushCounter(
+  std::optional<CounterId> id = context_->event_tracker->PushCounter(
       timestamp, static_cast<double>(num_of_kfree_skb_ip_prot), track);
   if (!id) {
     return;
diff --git a/src/trace_processor/importers/ftrace/rss_stat_tracker.cc b/src/trace_processor/importers/ftrace/rss_stat_tracker.cc
index 80ca10f..faebf94 100644
--- a/src/trace_processor/importers/ftrace/rss_stat_tracker.cc
+++ b/src/trace_processor/importers/ftrace/rss_stat_tracker.cc
@@ -47,8 +47,8 @@
                                   ConstBytes blob) {
   uint32_t member;
   int64_t size;
-  base::Optional<bool> curr;
-  base::Optional<int64_t> mm_id;
+  std::optional<bool> curr;
+  std::optional<int64_t> mm_id;
 
   if (field_id == FtraceEvent::kRssStatFieldNumber) {
     protos::pbzero::RssStatFtraceEvent::Decoder rss(blob.data, blob.size);
@@ -56,10 +56,10 @@
     member = static_cast<uint32_t>(rss.member());
     size = rss.size();
     if (rss.has_curr()) {
-      curr = base::make_optional(static_cast<bool>(rss.curr()));
+      curr = std::make_optional(static_cast<bool>(rss.curr()));
     }
     if (rss.has_mm_id()) {
-      mm_id = base::make_optional(rss.mm_id());
+      mm_id = std::make_optional(rss.mm_id());
     }
 
     ParseRssStat(ts, pid, size, member, curr, mm_id);
@@ -69,8 +69,8 @@
 
     member = static_cast<uint32_t>(rss.member());
     size = rss.size();
-    curr = base::make_optional(static_cast<bool>(rss.curr()));
-    mm_id = base::make_optional(rss.mm_id());
+    curr = std::make_optional(static_cast<bool>(rss.curr()));
+    mm_id = std::make_optional(rss.mm_id());
 
     ParseRssStat(ts, pid, size, member, curr, mm_id);
   } else {
@@ -82,8 +82,8 @@
                                   uint32_t pid,
                                   int64_t size,
                                   uint32_t member,
-                                  base::Optional<bool> curr,
-                                  base::Optional<int64_t> mm_id) {
+                                  std::optional<bool> curr,
+                                  std::optional<int64_t> mm_id) {
   const auto kRssStatUnknown = static_cast<uint32_t>(rss_members_.size()) - 1;
   if (member >= rss_members_.size()) {
     context_->storage->IncrementStats(stats::rss_stat_unknown_keys);
@@ -95,7 +95,7 @@
     return;
   }
 
-  base::Optional<UniqueTid> utid;
+  std::optional<UniqueTid> utid;
   if (mm_id.has_value() && curr.has_value()) {
     utid = FindUtidForMmId(*mm_id, *curr, pid);
   } else {
@@ -110,9 +110,9 @@
   }
 }
 
-base::Optional<UniqueTid> RssStatTracker::FindUtidForMmId(int64_t mm_id,
-                                                          bool is_curr,
-                                                          uint32_t pid) {
+std::optional<UniqueTid> RssStatTracker::FindUtidForMmId(int64_t mm_id,
+                                                         bool is_curr,
+                                                         uint32_t pid) {
   // If curr is true, we can just overwrite the state in the map and return
   // the utid correspodning to |pid|.
   if (is_curr) {
@@ -125,7 +125,7 @@
   // mm id.
   auto* it = mm_id_to_utid_.Find(mm_id);
   if (!it)
-    return base::nullopt;
+    return std::nullopt;
 
   // If the utid in the map is the same as our current utid but curr is false,
   // that means we are in the middle of a process changing mm structs (i.e. in
@@ -135,7 +135,7 @@
   const UniqueTid utid = context_->process_tracker->GetOrCreateThread(pid);
   if (mm_utid == utid) {
     mm_id_to_utid_.Erase(mm_id);
-    return base::nullopt;
+    return std::nullopt;
   }
 
   // Verify that the utid in the map is still alive. This can happen if an mm
@@ -143,7 +143,7 @@
   // know the new process that struct will be associated with.
   if (!context_->process_tracker->IsThreadAlive(mm_utid)) {
     mm_id_to_utid_.Erase(mm_id);
-    return base::nullopt;
+    return std::nullopt;
   }
 
   // This case happens when a process is changing the VM of another process and
diff --git a/src/trace_processor/importers/ftrace/rss_stat_tracker.h b/src/trace_processor/importers/ftrace/rss_stat_tracker.h
index b3ba29a..7139d6c 100644
--- a/src/trace_processor/importers/ftrace/rss_stat_tracker.h
+++ b/src/trace_processor/importers/ftrace/rss_stat_tracker.h
@@ -40,13 +40,13 @@
                     uint32_t pid,
                     int64_t size,
                     uint32_t member,
-                    base::Optional<bool> curr,
-                    base::Optional<int64_t> mm_id);
+                    std::optional<bool> curr,
+                    std::optional<int64_t> mm_id);
 
  private:
-  base::Optional<UniqueTid> FindUtidForMmId(int64_t mm_id,
-                                            bool is_curr,
-                                            uint32_t pid);
+  std::optional<UniqueTid> FindUtidForMmId(int64_t mm_id,
+                                           bool is_curr,
+                                           uint32_t pid);
 
   base::FlatHashMap<int64_t, UniqueTid> mm_id_to_utid_;
   std::vector<StringId> rss_members_;
diff --git a/src/trace_processor/importers/ftrace/sched_event_tracker.cc b/src/trace_processor/importers/ftrace/sched_event_tracker.cc
index 3ee1fa1..f67e571 100644
--- a/src/trace_processor/importers/ftrace/sched_event_tracker.cc
+++ b/src/trace_processor/importers/ftrace/sched_event_tracker.cc
@@ -313,7 +313,7 @@
 StringId SchedEventTracker::TaskStateToStringId(int64_t task_state_int) {
   using ftrace_utils::TaskState;
 
-  base::Optional<VersionNumber> kernel_version =
+  std::optional<VersionNumber> kernel_version =
       SystemInfoTracker::GetOrCreate(context_)->GetKernelVersion();
   TaskState task_state = TaskState::FromRawPrevState(
       static_cast<uint16_t>(task_state_int), kernel_version);
diff --git a/src/trace_processor/importers/ftrace/sched_event_tracker_unittest.cc b/src/trace_processor/importers/ftrace/sched_event_tracker_unittest.cc
index 22b1139..5d275d6 100644
--- a/src/trace_processor/importers/ftrace/sched_event_tracker_unittest.cc
+++ b/src/trace_processor/importers/ftrace/sched_event_tracker_unittest.cc
@@ -68,7 +68,7 @@
 
   const auto& timestamps = context.storage->sched_slice_table().ts();
   ASSERT_EQ(timestamps[0], timestamp);
-  ASSERT_EQ(context.storage->thread_table().start_ts()[1], base::nullopt);
+  ASSERT_EQ(context.storage->thread_table().start_ts()[1], std::nullopt);
 
   auto name = context.storage->thread_table().name().GetString(1);
   ASSERT_STREQ(name.c_str(), kCommProc1);
@@ -102,7 +102,7 @@
 
   const auto& timestamps = context.storage->sched_slice_table().ts();
   ASSERT_EQ(timestamps[0], timestamp);
-  ASSERT_EQ(context.storage->thread_table().start_ts()[1], base::nullopt);
+  ASSERT_EQ(context.storage->thread_table().start_ts()[1], std::nullopt);
   ASSERT_EQ(context.storage->sched_slice_table().dur()[0], 1u);
   ASSERT_EQ(context.storage->sched_slice_table().dur()[1], 11u - 1u);
   ASSERT_EQ(context.storage->sched_slice_table().dur()[2], 31u - 11u);
@@ -125,14 +125,14 @@
                                  prio, prev_state,
                                  /*tid=*/1, kCommProc2, prio);
 
-  context.process_tracker->SetProcessMetadata(2, base::nullopt, "test",
+  context.process_tracker->SetProcessMetadata(2, std::nullopt, "test",
                                               base::StringView());
   context.process_tracker->UpdateThread(4, 2);
 
   ASSERT_EQ(context.storage->thread_table().tid()[1], 4u);
   ASSERT_EQ(context.storage->thread_table().upid()[1].value(), 1u);
   ASSERT_EQ(context.storage->process_table().pid()[1], 2u);
-  ASSERT_EQ(context.storage->process_table().start_ts()[1], base::nullopt);
+  ASSERT_EQ(context.storage->process_table().start_ts()[1], std::nullopt);
 }
 
 }  // namespace
diff --git a/src/trace_processor/importers/ftrace/thread_state_tracker.cc b/src/trace_processor/importers/ftrace/thread_state_tracker.cc
index 227a90a..3c6b123 100644
--- a/src/trace_processor/importers/ftrace/thread_state_tracker.cc
+++ b/src/trace_processor/importers/ftrace/thread_state_tracker.cc
@@ -67,19 +67,19 @@
 
   // Close the sleeping state and open runnable state.
   ClosePendingState(event_ts, utid, false);
-  AddOpenState(event_ts, utid, runnable_string_id_, base::nullopt, waker_utid);
+  AddOpenState(event_ts, utid, runnable_string_id_, std::nullopt, waker_utid);
 }
 
 void ThreadStateTracker::PushNewTaskEvent(int64_t event_ts,
                                          UniqueTid utid,
                                          UniqueTid waker_utid) {
-  AddOpenState(event_ts, utid, runnable_string_id_, base::nullopt, waker_utid);
+  AddOpenState(event_ts, utid, runnable_string_id_, std::nullopt, waker_utid);
 }
 
 void ThreadStateTracker::PushBlockedReason(
     UniqueTid utid,
-    base::Optional<bool> io_wait,
-    base::Optional<StringId> blocked_function) {
+    std::optional<bool> io_wait,
+    std::optional<StringId> blocked_function) {
   // Return if there is no state, as there is are no previous rows available.
   if (!HasPreviousRowNumbersForUtid(utid))
     return;
@@ -102,8 +102,8 @@
 void ThreadStateTracker::AddOpenState(int64_t ts,
                                       UniqueTid utid,
                                       StringId state,
-                                      base::Optional<uint32_t> cpu,
-                                      base::Optional<UniqueTid> waker_utid) {
+                                      std::optional<uint32_t> cpu,
+                                      std::optional<UniqueTid> waker_utid) {
   // Ignore utid 0 because it corresponds to the swapper thread which doesn't
   // make sense to insert.
   if (utid == 0)
@@ -124,11 +124,11 @@
   }
 
   if (!prev_row_numbers_for_thread_[utid].has_value()) {
-    prev_row_numbers_for_thread_[utid] = RelatedRows{base::nullopt, row_num};
+    prev_row_numbers_for_thread_[utid] = RelatedRows{std::nullopt, row_num};
   }
 
   if (IsRunning(state)) {
-    prev_row_numbers_for_thread_[utid] = RelatedRows{base::nullopt, row_num};
+    prev_row_numbers_for_thread_[utid] = RelatedRows{std::nullopt, row_num};
   } else if (IsBlocked(state)) {
     prev_row_numbers_for_thread_[utid] = RelatedRows{row_num, row_num};
   } else /* if (IsRunnable(state)) */ {
diff --git a/src/trace_processor/importers/ftrace/thread_state_tracker.h b/src/trace_processor/importers/ftrace/thread_state_tracker.h
index 3f8b7a5..7faae9c 100644
--- a/src/trace_processor/importers/ftrace/thread_state_tracker.h
+++ b/src/trace_processor/importers/ftrace/thread_state_tracker.h
@@ -57,15 +57,15 @@
 
   // Updates the current blocked state for utid with blocked reason.
   void PushBlockedReason(UniqueTid utid,
-                         base::Optional<bool> io_wait,
-                         base::Optional<StringId> blocked_function);
+                         std::optional<bool> io_wait,
+                         std::optional<StringId> blocked_function);
 
  private:
   void AddOpenState(int64_t ts,
                     UniqueTid utid,
                     StringId state,
-                    base::Optional<uint32_t> cpu = base::nullopt,
-                    base::Optional<UniqueTid> waker_utid = base::nullopt);
+                    std::optional<uint32_t> cpu = std::nullopt,
+                    std::optional<UniqueTid> waker_utid = std::nullopt);
   void ClosePendingState(int64_t end_ts, UniqueTid utid, bool data_loss);
 
   bool IsRunning(StringId state);
@@ -89,11 +89,11 @@
   StringId runnable_string_id_;
 
   struct RelatedRows {
-    base::Optional<tables::ThreadStateTable::RowNumber> last_blocked_row;
+    std::optional<tables::ThreadStateTable::RowNumber> last_blocked_row;
     tables::ThreadStateTable::RowNumber last_row;
   };
 
-  std::vector<base::Optional<RelatedRows>> prev_row_numbers_for_thread_;
+  std::vector<std::optional<RelatedRows>> prev_row_numbers_for_thread_;
 };
 }  // namespace trace_processor
 }  // namespace perfetto
diff --git a/src/trace_processor/importers/ftrace/thread_state_tracker_unittest.cc b/src/trace_processor/importers/ftrace/thread_state_tracker_unittest.cc
index 0c6c370..e706a2e 100644
--- a/src/trace_processor/importers/ftrace/thread_state_tracker_unittest.cc
+++ b/src/trace_processor/importers/ftrace/thread_state_tracker_unittest.cc
@@ -58,13 +58,13 @@
   void VerifyThreadState(
       const tables::ThreadStateTable::ConstIterator& it,
       int64_t from,
-      base::Optional<int64_t> to,
+      std::optional<int64_t> to,
       UniqueTid utid,
       const char* state,
-      base::Optional<bool> io_wait = base::nullopt,
-      base::Optional<StringId> blocked_function = base::nullopt,
-      base::Optional<UniqueTid> waker_utid = base::nullopt,
-      base::Optional<int64_t> cpu = base::nullopt) {
+      std::optional<bool> io_wait = std::nullopt,
+      std::optional<StringId> blocked_function = std::nullopt,
+      std::optional<UniqueTid> waker_utid = std::nullopt,
+      std::optional<int64_t> cpu = std::nullopt) {
     ASSERT_EQ(it.ts(), from);
     ASSERT_EQ(it.dur(), to ? *to - from : -1);
     ASSERT_EQ(it.utid(), utid);
@@ -75,7 +75,7 @@
         ASSERT_EQ(it.cpu(), CPU_A);
       }
     } else {
-      ASSERT_EQ(it.cpu(), base::nullopt);
+      ASSERT_EQ(it.cpu(), std::nullopt);
     }
     ASSERT_STREQ(context_.storage->GetString(it.state()).c_str(), state);
     ASSERT_EQ(it.io_wait(), io_wait);
@@ -97,8 +97,8 @@
 
   ASSERT_EQ(context_.storage->thread_state_table().row_count(), 2ul);
   auto rows_it = ThreadStateIterator();
-  VerifyThreadState(rows_it, 10, base::nullopt, THREAD_A, "S");
-  VerifyThreadState(++rows_it, 10, base::nullopt, THREAD_B, kRunning);
+  VerifyThreadState(rows_it, 10, std::nullopt, THREAD_A, "S");
+  VerifyThreadState(++rows_it, 10, std::nullopt, THREAD_B, kRunning);
 }
 
 TEST_F(ThreadStateTrackerUnittest, StartWithWakingEvent) {
@@ -114,9 +114,9 @@
   ASSERT_EQ(context_.storage->thread_state_table().row_count(), 3ul);
   auto row_it = ThreadStateIterator();
   VerifyThreadState(row_it, 10, 20, THREAD_A, "S");
-  VerifyThreadState(++row_it, 10, base::nullopt, THREAD_B, kRunning);
-  VerifyThreadState(++row_it, 20, base::nullopt, THREAD_A, kRunnable,
-                    base::nullopt, base::nullopt, THREAD_C);
+  VerifyThreadState(++row_it, 10, std::nullopt, THREAD_B, kRunning);
+  VerifyThreadState(++row_it, 20, std::nullopt, THREAD_A, kRunnable,
+                    std::nullopt, std::nullopt, THREAD_C);
 }
 
 TEST_F(ThreadStateTrackerUnittest, BasicPushBlockedReason) {
@@ -125,7 +125,7 @@
   tracker_->PushBlockedReason(THREAD_A, true, StringIdOf(kBlockedFunction));
 
   auto rows_it = ThreadStateIterator();
-  VerifyThreadState(rows_it, 10, base::nullopt, THREAD_A, "S", true,
+  VerifyThreadState(rows_it, 10, std::nullopt, THREAD_A, "S", true,
                     StringIdOf(kBlockedFunction));
 }
 
@@ -150,7 +150,7 @@
 
   // The opening of idle_thred should be discarded so the first row will be
   // for the THREAD_A.
-  VerifyThreadState(rows_it, 10, base::nullopt, THREAD_A, kRunning);
+  VerifyThreadState(rows_it, 10, std::nullopt, THREAD_A, kRunning);
 }
 
 TEST_F(ThreadStateTrackerUnittest, SchedBlockedReasonWithIdleThread) {
@@ -158,19 +158,19 @@
                                  THREAD_A);
   tracker_->PushSchedSwitchEvent(2, CPU_A, THREAD_A, StringIdOf("D"),
                                  IDLE_THREAD);
-  tracker_->PushBlockedReason(THREAD_A, IDLE_THREAD, base::nullopt);
+  tracker_->PushBlockedReason(THREAD_A, IDLE_THREAD, std::nullopt);
   tracker_->PushSchedSwitchEvent(3, CPU_A, IDLE_THREAD, StringIdOf("D"),
                                  THREAD_B);
   tracker_->PushSchedSwitchEvent(4, CPU_A, THREAD_B, StringIdOf("D"),
                                  IDLE_THREAD);
-  tracker_->PushBlockedReason(THREAD_B, 1, base::nullopt);
+  tracker_->PushBlockedReason(THREAD_B, 1, std::nullopt);
 
   auto rows_it = ThreadStateIterator();
 
   VerifyThreadState(rows_it, 1, 2, THREAD_A, kRunning);
-  VerifyThreadState(++rows_it, 2, base::nullopt, THREAD_A, "D", 0);
+  VerifyThreadState(++rows_it, 2, std::nullopt, THREAD_A, "D", 0);
   VerifyThreadState(++rows_it, 3, 4, THREAD_B, kRunning);
-  VerifyThreadState(++rows_it, 4, base::nullopt, THREAD_B, "D", 1);
+  VerifyThreadState(++rows_it, 4, std::nullopt, THREAD_B, "D", 1);
 }
 
 TEST_F(ThreadStateTrackerUnittest, SchedSwitchForcedMigration) {
@@ -178,7 +178,7 @@
   tracker_->PushSchedSwitchEvent(2, CPU_A, THREAD_A, StringIdOf("S"), THREAD_B);
 
   auto rows_it = ThreadStateIterator();
-  VerifyThreadState(rows_it, 1, base::nullopt, THREAD_A, "S");
+  VerifyThreadState(rows_it, 1, std::nullopt, THREAD_A, "S");
   VerifyThreadState(++rows_it, 1, 2, THREAD_B, kRunning);
 }
 
@@ -192,12 +192,12 @@
   tracker_->PushSchedSwitchEvent(7, CPU_A, 0, StringIdOf(kRunnable), 18);
 
   auto rows_it = ThreadStateIterator();
-  VerifyThreadState(rows_it, 2, base::nullopt, 11, "S");
-  VerifyThreadState(++rows_it, 3, base::nullopt, 8, "S");
-  VerifyThreadState(++rows_it, 4, base::nullopt, 17771, "S");
+  VerifyThreadState(rows_it, 2, std::nullopt, 11, "S");
+  VerifyThreadState(++rows_it, 3, std::nullopt, 8, "S");
+  VerifyThreadState(++rows_it, 4, std::nullopt, 17771, "S");
   VerifyThreadState(++rows_it, 4, 5, 17772, kRunning);
-  VerifyThreadState(++rows_it, 5, base::nullopt, 17772, "S");
-  VerifyThreadState(++rows_it, 7, base::nullopt, 18, kRunning);
+  VerifyThreadState(++rows_it, 5, std::nullopt, 17772, "S");
+  VerifyThreadState(++rows_it, 7, std::nullopt, 18, kRunning);
 }
 
 TEST_F(ThreadStateTrackerUnittest, RunningOnMultipleCPUsForcedMigration) {
@@ -206,11 +206,11 @@
   tracker_->PushSchedSwitchEvent(2, CPU_B, THREAD_B, StringIdOf("S"), THREAD_A);
 
   auto rows_it = ThreadStateIterator();
-  VerifyThreadState(rows_it, 1, base::nullopt, THREAD_C, "S");
+  VerifyThreadState(rows_it, 1, std::nullopt, THREAD_C, "S");
   VerifyThreadState(++rows_it, 1, 2, THREAD_A, kRunning);
-  VerifyThreadState(++rows_it, 2, base::nullopt, THREAD_B, "S");
-  VerifyThreadState(++rows_it, 2, base::nullopt, THREAD_A, kRunning,
-                    base::nullopt, base::nullopt, base::nullopt, CPU_B);
+  VerifyThreadState(++rows_it, 2, std::nullopt, THREAD_B, "S");
+  VerifyThreadState(++rows_it, 2, std::nullopt, THREAD_A, kRunning,
+                    std::nullopt, std::nullopt, std::nullopt, CPU_B);
 }
 
 }  // namespace
diff --git a/src/trace_processor/importers/ftrace/v4l2_tracker.cc b/src/trace_processor/importers/ftrace/v4l2_tracker.cc
index 18546e9..c441fb1 100644
--- a/src/trace_processor/importers/ftrace/v4l2_tracker.cc
+++ b/src/trace_processor/importers/ftrace/v4l2_tracker.cc
@@ -88,7 +88,7 @@
 
       StringId buf_name_id =
           context_->storage->InternString(buf_name.string_view());
-      base::Optional<SliceId> slice_id =
+      std::optional<SliceId> slice_id =
           AddSlice(buf_name_id, timestamp, pid, evt);
 
       uint64_t hash = base::Hasher::Combine(evt.device_minor, evt.sequence,
@@ -129,7 +129,7 @@
 
       StringId buf_name_id =
           context_->storage->InternString(buf_name.string_view());
-      base::Optional<SliceId> slice_id =
+      std::optional<SliceId> slice_id =
           AddSlice(buf_name_id, timestamp, pid, evt);
 
       uint64_t hash = base::Hasher::Combine(evt.device_minor, evt.sequence,
@@ -150,9 +150,9 @@
       Vb2V4l2BufQueueFtraceEvent::Decoder pb_evt(bytes.data, bytes.size);
       BufferEvent evt;
       evt.device_minor = pb_evt.minor();
-      evt.index = base::nullopt;
-      evt.type = base::nullopt;
-      evt.bytesused = base::nullopt;
+      evt.index = std::nullopt;
+      evt.type = std::nullopt;
+      evt.bytesused = std::nullopt;
       evt.flags = pb_evt.flags();
       evt.field = pb_evt.field();
       evt.timestamp = pb_evt.timestamp();
@@ -181,9 +181,9 @@
       Vb2V4l2BufDoneFtraceEvent::Decoder pb_evt(bytes.data, bytes.size);
       BufferEvent evt;
       evt.device_minor = pb_evt.minor();
-      evt.index = base::nullopt;
-      evt.type = base::nullopt;
-      evt.bytesused = base::nullopt;
+      evt.index = std::nullopt;
+      evt.type = std::nullopt;
+      evt.bytesused = std::nullopt;
       evt.flags = pb_evt.flags();
       evt.field = pb_evt.field();
       evt.timestamp = pb_evt.timestamp();
@@ -212,9 +212,9 @@
       Vb2V4l2QbufFtraceEvent::Decoder pb_evt(bytes.data, bytes.size);
       BufferEvent evt;
       evt.device_minor = pb_evt.minor();
-      evt.index = base::nullopt;
-      evt.type = base::nullopt;
-      evt.bytesused = base::nullopt;
+      evt.index = std::nullopt;
+      evt.type = std::nullopt;
+      evt.bytesused = std::nullopt;
       evt.flags = pb_evt.flags();
       evt.field = pb_evt.field();
       evt.timestamp = pb_evt.timestamp();
@@ -243,9 +243,9 @@
       Vb2V4l2DqbufFtraceEvent::Decoder pb_evt(bytes.data, bytes.size);
       BufferEvent evt;
       evt.device_minor = pb_evt.minor();
-      evt.index = base::nullopt;
-      evt.type = base::nullopt;
-      evt.bytesused = base::nullopt;
+      evt.index = std::nullopt;
+      evt.type = std::nullopt;
+      evt.bytesused = std::nullopt;
       evt.flags = pb_evt.flags();
       evt.field = pb_evt.field();
       evt.timestamp = pb_evt.timestamp();
@@ -275,14 +275,14 @@
   }
 }
 
-base::Optional<SliceId> V4l2Tracker::AddSlice(StringId buf_name_id,
-                                              int64_t timestamp,
-                                              uint32_t pid,
-                                              const BufferEvent& evt) {
+std::optional<SliceId> V4l2Tracker::AddSlice(StringId buf_name_id,
+                                             int64_t timestamp,
+                                             uint32_t pid,
+                                             const BufferEvent& evt) {
   UniqueTid utid = context_->process_tracker->GetOrCreateThread(pid);
   TrackId track_id = context_->track_tracker->InternThreadTrack(utid);
 
-  base::Optional<SliceId> slice_id = context_->slice_tracker->Scoped(
+  std::optional<SliceId> slice_id = context_->slice_tracker->Scoped(
       timestamp, track_id, buf_event_ids_.v4l2, buf_name_id, 0,
       [this, &evt](ArgsTracker::BoundInserter* inserter) {
         this->AddArgs(evt, inserter);
diff --git a/src/trace_processor/importers/ftrace/v4l2_tracker.h b/src/trace_processor/importers/ftrace/v4l2_tracker.h
index f204e1d..057d7e4 100644
--- a/src/trace_processor/importers/ftrace/v4l2_tracker.h
+++ b/src/trace_processor/importers/ftrace/v4l2_tracker.h
@@ -19,9 +19,9 @@
 
 #include <stdint.h>
 #include <cstdint>
+#include <optional>
 
 #include "perfetto/ext/base/flat_hash_map.h"
-#include "perfetto/ext/base/optional.h"
 
 #include "perfetto/protozero/field.h"
 #include "src/trace_processor/importers/common/args_tracker.h"
@@ -58,9 +58,9 @@
   struct BufferEvent {
    public:
     int32_t device_minor;
-    base::Optional<uint32_t> index;
-    base::Optional<uint32_t> type;
-    base::Optional<uint32_t> bytesused;
+    std::optional<uint32_t> index;
+    std::optional<uint32_t> type;
+    std::optional<uint32_t> bytesused;
     uint32_t flags;
     uint32_t field;
     int64_t timestamp;
@@ -155,13 +155,13 @@
   };
 
   struct QueuedBuffer {
-    base::Optional<SliceId> queue_slice_id;
+    std::optional<SliceId> queue_slice_id;
   };
 
-  base::Optional<SliceId> AddSlice(StringId buf_name_id,
-                                   int64_t timestamp,
-                                   uint32_t pid,
-                                   const BufferEvent& evt);
+  std::optional<SliceId> AddSlice(StringId buf_name_id,
+                                  int64_t timestamp,
+                                  uint32_t pid,
+                                  const BufferEvent& evt);
 
   void AddArgs(const BufferEvent& evt, ArgsTracker::BoundInserter* inserter);
 
diff --git a/src/trace_processor/importers/fuchsia/fuchsia_parser_unittest.cc b/src/trace_processor/importers/fuchsia/fuchsia_parser_unittest.cc
index 349e9d0..cf0d569 100644
--- a/src/trace_processor/importers/fuchsia/fuchsia_parser_unittest.cc
+++ b/src/trace_processor/importers/fuchsia/fuchsia_parser_unittest.cc
@@ -115,7 +115,7 @@
 
   MOCK_METHOD4(SetProcessMetadata,
                UniquePid(uint32_t pid,
-                         base::Optional<uint32_t> ppid,
+                         std::optional<uint32_t> ppid,
                          base::StringView process_name,
                          base::StringView cmdline));
 
@@ -169,9 +169,9 @@
                     int32_t next_prio));
 
   MOCK_METHOD3(PushCounter,
-               base::Optional<CounterId>(int64_t timestamp,
-                                         double value,
-                                         TrackId track_id));
+               std::optional<CounterId>(int64_t timestamp,
+                                        double value,
+                                        TrackId track_id));
 };
 
 class MockSliceTracker : public SliceTracker {
@@ -180,29 +180,29 @@
       : SliceTracker(context) {}
 
   MOCK_METHOD5(Begin,
-               base::Optional<SliceId>(int64_t timestamp,
-                                       TrackId track_id,
-                                       StringId cat,
-                                       StringId name,
-                                       SetArgsCallback args_callback));
+               std::optional<SliceId>(int64_t timestamp,
+                                      TrackId track_id,
+                                      StringId cat,
+                                      StringId name,
+                                      SetArgsCallback args_callback));
   MOCK_METHOD5(End,
-               base::Optional<SliceId>(int64_t timestamp,
-                                       TrackId track_id,
-                                       StringId cat,
-                                       StringId name,
-                                       SetArgsCallback args_callback));
+               std::optional<SliceId>(int64_t timestamp,
+                                      TrackId track_id,
+                                      StringId cat,
+                                      StringId name,
+                                      SetArgsCallback args_callback));
   MOCK_METHOD6(Scoped,
-               base::Optional<SliceId>(int64_t timestamp,
-                                       TrackId track_id,
-                                       StringId cat,
-                                       StringId name,
-                                       int64_t duration,
-                                       SetArgsCallback args_callback));
+               std::optional<SliceId>(int64_t timestamp,
+                                      TrackId track_id,
+                                      StringId cat,
+                                      StringId name,
+                                      int64_t duration,
+                                      SetArgsCallback args_callback));
   MOCK_METHOD4(StartSlice,
-               base::Optional<SliceId>(int64_t timestamp,
-                                       TrackId track_id,
-                                       SetArgsCallback args_callback,
-                                       std::function<SliceId()> inserter));
+               std::optional<SliceId>(int64_t timestamp,
+                                      TrackId track_id,
+                                      SetArgsCallback args_callback,
+                                      std::function<SliceId()> inserter));
 };
 
 class FuchsiaTraceParserTest : public ::testing::Test {
diff --git a/src/trace_processor/importers/fuchsia/fuchsia_trace_tokenizer.cc b/src/trace_processor/importers/fuchsia/fuchsia_trace_tokenizer.cc
index 514bfcb..d2dbb1f 100644
--- a/src/trace_processor/importers/fuchsia/fuchsia_trace_tokenizer.cc
+++ b/src/trace_processor/importers/fuchsia/fuchsia_trace_tokenizer.cc
@@ -593,7 +593,7 @@
           // artificial koids which have the 2^63 bit set. This is used for
           // things such as virtual threads.
           procs->SetProcessMetadata(
-              static_cast<uint32_t>(obj_id), base::Optional<uint32_t>(),
+              static_cast<uint32_t>(obj_id), std::optional<uint32_t>(),
               base::StringView(storage->GetString(name)), base::StringView());
           break;
         }
diff --git a/src/trace_processor/importers/fuchsia/fuchsia_trace_tokenizer.h b/src/trace_processor/importers/fuchsia/fuchsia_trace_tokenizer.h
index 4b4d610..671060e 100644
--- a/src/trace_processor/importers/fuchsia/fuchsia_trace_tokenizer.h
+++ b/src/trace_processor/importers/fuchsia/fuchsia_trace_tokenizer.h
@@ -73,8 +73,8 @@
 
     FuchsiaThreadInfo info;
     int64_t last_ts{0};
-    base::Optional<tables::SchedSliceTable::RowNumber> last_slice_row;
-    base::Optional<tables::ThreadStateTable::RowNumber> last_state_row;
+    std::optional<tables::SchedSliceTable::RowNumber> last_slice_row;
+    std::optional<tables::ThreadStateTable::RowNumber> last_state_row;
   };
 
   void SwitchFrom(Thread* thread,
diff --git a/src/trace_processor/importers/json/json_trace_parser.cc b/src/trace_processor/importers/json/json_trace_parser.cc
index 50cf243..b087963 100644
--- a/src/trace_processor/importers/json/json_trace_parser.cc
+++ b/src/trace_processor/importers/json/json_trace_parser.cc
@@ -18,10 +18,10 @@
 
 #include <cinttypes>
 #include <limits>
+#include <optional>
 #include <string>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/string_view.h"
 #include "src/trace_processor/importers/common/event_tracker.h"
@@ -39,16 +39,16 @@
 #if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
 namespace {
 
-base::Optional<uint64_t> MaybeExtractFlowIdentifier(const Json::Value& value,
-                                                    bool version2) {
+std::optional<uint64_t> MaybeExtractFlowIdentifier(const Json::Value& value,
+                                                   bool version2) {
   std::string id_key = (version2 ? "bind_id" : "id");
   if (!value.isMember(id_key))
-    return base::nullopt;
+    return std::nullopt;
   auto id = value[id_key];
   if (id.isNumeric())
     return id.asUInt64();
   if (!id.isString())
-    return base::nullopt;
+    return std::nullopt;
   const char* c_string = id.asCString();
   return base::CStringToUInt64(c_string, 16);
 }
@@ -87,8 +87,8 @@
     return;
   char phase = *ph.asCString();
 
-  base::Optional<uint32_t> opt_pid;
-  base::Optional<uint32_t> opt_tid;
+  std::optional<uint32_t> opt_pid;
+  std::optional<uint32_t> opt_tid;
 
   if (value.isMember("pid"))
     opt_pid = json::CoerceToUint32(value["pid"]);
@@ -132,8 +132,8 @@
     // tdur will only exist on 'X' events.
     row.thread_dur = json::CoerceToTs(value["tdur"]);
     // JSON traces don't report these counters as part of slices.
-    row.thread_instruction_count = base::nullopt;
-    row.thread_instruction_delta = base::nullopt;
+    row.thread_instruction_count = std::nullopt;
+    row.thread_instruction_delta = std::nullopt;
     return row;
   };
 
@@ -191,7 +191,7 @@
       break;
     }
     case 'X': {  // TRACE_EVENT (scoped event).
-      base::Optional<int64_t> opt_dur = json::CoerceToTs(value["dur"]);
+      std::optional<int64_t> opt_dur = json::CoerceToTs(value["dur"]);
       if (!opt_dur.has_value())
         return;
       TrackId track_id = context_->track_tracker->InternThreadTrack(utid);
@@ -333,7 +333,7 @@
       }
       if (name == "process_name" && !value["args"]["name"].empty()) {
         const char* proc_name = value["args"]["name"].asCString();
-        procs->SetProcessMetadata(pid, base::nullopt, proc_name,
+        procs->SetProcessMetadata(pid, std::nullopt, proc_name,
                                   base::StringView());
         break;
       }
diff --git a/src/trace_processor/importers/json/json_trace_tokenizer.cc b/src/trace_processor/importers/json/json_trace_tokenizer.cc
index a385edf..12414f2 100644
--- a/src/trace_processor/importers/json/json_trace_tokenizer.cc
+++ b/src/trace_processor/importers/json/json_trace_tokenizer.cc
@@ -298,7 +298,7 @@
 
 base::Status ExtractValueForJsonKey(base::StringView dict,
                                     const std::string& key,
-                                    base::Optional<std::string>* value) {
+                                    std::optional<std::string>* value) {
   PERFETTO_DCHECK(dict.size() >= 2);
 
   const char* start = dict.data();
@@ -398,7 +398,7 @@
   if (state != kAfterDict)
     return base::ErrStatus("Failure parsing JSON: malformed dictionary");
 
-  *value = base::nullopt;
+  *value = std::nullopt;
   return base::OkStatus();
 }
 
@@ -531,16 +531,16 @@
         break;
     }
 
-    base::Optional<std::string> opt_raw_ts;
+    std::optional<std::string> opt_raw_ts;
     RETURN_IF_ERROR(ExtractValueForJsonKey(unparsed, "ts", &opt_raw_ts));
-    base::Optional<int64_t> opt_ts =
-        opt_raw_ts ? json::CoerceToTs(*opt_raw_ts) : base::nullopt;
+    std::optional<int64_t> opt_ts =
+        opt_raw_ts ? json::CoerceToTs(*opt_raw_ts) : std::nullopt;
     int64_t ts = 0;
     if (opt_ts.has_value()) {
       ts = opt_ts.value();
     } else {
       // Metadata events may omit ts. In all other cases error:
-      base::Optional<std::string> opt_raw_ph;
+      std::optional<std::string> opt_raw_ph;
       RETURN_IF_ERROR(ExtractValueForJsonKey(unparsed, "ph", &opt_raw_ph));
       if (!opt_raw_ph || *opt_raw_ph != "M") {
         context_->storage->IncrementStats(stats::json_tokenizer_failure);
diff --git a/src/trace_processor/importers/json/json_trace_tokenizer.h b/src/trace_processor/importers/json/json_trace_tokenizer.h
index 3713636..61f1d77 100644
--- a/src/trace_processor/importers/json/json_trace_tokenizer.h
+++ b/src/trace_processor/importers/json/json_trace_tokenizer.h
@@ -79,7 +79,7 @@
 // Visible for testing.
 base::Status ExtractValueForJsonKey(base::StringView dict,
                                     const std::string& key,
-                                    base::Optional<std::string>* value);
+                                    std::optional<std::string>* value);
 
 enum class ReadSystemLineRes {
   kFoundLine,
diff --git a/src/trace_processor/importers/json/json_trace_tokenizer_unittest.cc b/src/trace_processor/importers/json/json_trace_tokenizer_unittest.cc
index 051f52a..22a3885 100644
--- a/src/trace_processor/importers/json/json_trace_tokenizer_unittest.cc
+++ b/src/trace_processor/importers/json/json_trace_tokenizer_unittest.cc
@@ -226,7 +226,7 @@
 }
 
 TEST(JsonTraceTokenizerTest, ExtractValueForJsonKey) {
-  base::Optional<std::string> line;
+  std::optional<std::string> line;
 
   ASSERT_TRUE(ExtractValueForJsonKey(R"({"ts": 149029})", "ts", &line).ok());
   ASSERT_EQ(*line, "149029");
diff --git a/src/trace_processor/importers/json/json_utils.cc b/src/trace_processor/importers/json/json_utils.cc
index 432ddbe..be9492b 100644
--- a/src/trace_processor/importers/json/json_utils.cc
+++ b/src/trace_processor/importers/json/json_utils.cc
@@ -37,7 +37,7 @@
 #endif
 }
 
-base::Optional<int64_t> CoerceToTs(const Json::Value& value) {
+std::optional<int64_t> CoerceToTs(const Json::Value& value) {
   PERFETTO_DCHECK(IsJsonSupported());
 
 #if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
@@ -50,36 +50,36 @@
     case Json::stringValue:
       return CoerceToTs(value.asString());
     default:
-      return base::nullopt;
+      return std::nullopt;
   }
 #else
   perfetto::base::ignore_result(value);
-  return base::nullopt;
+  return std::nullopt;
 #endif
 }
 
-base::Optional<int64_t> CoerceToTs(const std::string& s) {
+std::optional<int64_t> CoerceToTs(const std::string& s) {
   PERFETTO_DCHECK(IsJsonSupported());
 
 #if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
   size_t lhs_end = std::min<size_t>(s.find('.'), s.size());
   size_t rhs_start = std::min<size_t>(lhs_end + 1, s.size());
-  base::Optional<int64_t> lhs = base::StringToInt64(s.substr(0, lhs_end));
-  base::Optional<double> rhs =
+  std::optional<int64_t> lhs = base::StringToInt64(s.substr(0, lhs_end));
+  std::optional<double> rhs =
       base::StringToDouble("0." + s.substr(rhs_start, std::string::npos));
   if ((!lhs.has_value() && lhs_end > 0) ||
       (!rhs.has_value() && rhs_start < s.size())) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return lhs.value_or(0) * 1000 +
          static_cast<int64_t>(rhs.value_or(0) * 1000.0);
 #else
   perfetto::base::ignore_result(s);
-  return base::nullopt;
+  return std::nullopt;
 #endif
 }
 
-base::Optional<int64_t> CoerceToInt64(const Json::Value& value) {
+std::optional<int64_t> CoerceToInt64(const Json::Value& value) {
   PERFETTO_DCHECK(IsJsonSupported());
 
 #if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
@@ -94,36 +94,36 @@
       char* end;
       int64_t n = strtoll(s.c_str(), &end, 10);
       if (end != s.data() + s.size())
-        return base::nullopt;
+        return std::nullopt;
       return n;
     }
     default:
-      return base::nullopt;
+      return std::nullopt;
   }
 #else
   perfetto::base::ignore_result(value);
-  return base::nullopt;
+  return std::nullopt;
 #endif
 }
 
-base::Optional<uint32_t> CoerceToUint32(const Json::Value& value) {
+std::optional<uint32_t> CoerceToUint32(const Json::Value& value) {
   PERFETTO_DCHECK(IsJsonSupported());
 
 #if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
-  base::Optional<int64_t> result = CoerceToInt64(value);
+  std::optional<int64_t> result = CoerceToInt64(value);
   if (!result.has_value())
-    return base::nullopt;
+    return std::nullopt;
   int64_t n = result.value();
   if (n < 0 || n > std::numeric_limits<uint32_t>::max())
-    return base::nullopt;
+    return std::nullopt;
   return static_cast<uint32_t>(n);
 #else
   perfetto::base::ignore_result(value);
-  return base::nullopt;
+  return std::nullopt;
 #endif
 }
 
-base::Optional<Json::Value> ParseJsonString(base::StringView raw_string) {
+std::optional<Json::Value> ParseJsonString(base::StringView raw_string) {
   PERFETTO_DCHECK(IsJsonSupported());
 
 #if PERFETTO_BUILDFLAG(PERFETTO_TP_JSON)
@@ -133,11 +133,11 @@
   Json::Value value;
   const char* begin = raw_string.data();
   return reader->parse(begin, begin + raw_string.size(), &value, nullptr)
-             ? base::make_optional(std::move(value))
-             : base::nullopt;
+             ? std::make_optional(std::move(value))
+             : std::nullopt;
 #else
   perfetto::base::ignore_result(raw_string);
-  return base::nullopt;
+  return std::nullopt;
 #endif
 }
 
diff --git a/src/trace_processor/importers/json/json_utils.h b/src/trace_processor/importers/json/json_utils.h
index 1cbcae8..b9d0762 100644
--- a/src/trace_processor/importers/json/json_utils.h
+++ b/src/trace_processor/importers/json/json_utils.h
@@ -18,8 +18,8 @@
 #define SRC_TRACE_PROCESSOR_IMPORTERS_JSON_JSON_UTILS_H_
 
 #include <stdint.h>
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 
 #include "src/trace_processor/importers/common/args_tracker.h"
@@ -40,14 +40,14 @@
 // build flags.
 bool IsJsonSupported();
 
-base::Optional<int64_t> CoerceToTs(const Json::Value& value);
-base::Optional<int64_t> CoerceToTs(const std::string& value);
-base::Optional<int64_t> CoerceToInt64(const Json::Value& value);
-base::Optional<uint32_t> CoerceToUint32(const Json::Value& value);
+std::optional<int64_t> CoerceToTs(const Json::Value& value);
+std::optional<int64_t> CoerceToTs(const std::string& value);
+std::optional<int64_t> CoerceToInt64(const Json::Value& value);
+std::optional<uint32_t> CoerceToUint32(const Json::Value& value);
 
 // Parses the given JSON string into a JSON::Value object.
 // This function should only be called if |IsJsonSupported()| returns true.
-base::Optional<Json::Value> ParseJsonString(base::StringView raw_string);
+std::optional<Json::Value> ParseJsonString(base::StringView raw_string);
 
 // Flattens the given Json::Value and adds each leaf node to the bound args
 // inserter. Note:
diff --git a/src/trace_processor/importers/memory_tracker/graph_processor.cc b/src/trace_processor/importers/memory_tracker/graph_processor.cc
index 85dc9ad..77e40a9 100644
--- a/src/trace_processor/importers/memory_tracker/graph_processor.cc
+++ b/src/trace_processor/importers/memory_tracker/graph_processor.cc
@@ -42,14 +42,14 @@
   }
 }
 
-base::Optional<uint64_t> GetSizeEntryOfNode(Node* node) {
+std::optional<uint64_t> GetSizeEntryOfNode(Node* node) {
   auto size_it = node->entries()->find(kSizeEntryName);
   if (size_it == node->entries()->end())
-    return base::nullopt;
+    return std::nullopt;
 
   PERFETTO_DCHECK(size_it->second.type == Node::Entry::Type::kUInt64);
   PERFETTO_DCHECK(size_it->second.units == Node::Entry::ScalarUnits::kBytes);
-  return base::Optional<uint64_t>(size_it->second.value_uint64);
+  return std::optional<uint64_t>(size_it->second.value_uint64);
 }
 
 }  // namespace
@@ -530,17 +530,17 @@
 }
 
 // static
-base::Optional<uint64_t> GraphProcessor::AggregateSizeForDescendantNode(
+std::optional<uint64_t> GraphProcessor::AggregateSizeForDescendantNode(
     Node* root,
     Node* descendant) {
   Edge* owns_edge = descendant->owns_edge();
   if (owns_edge && owns_edge->target()->IsDescendentOf(*root))
-    return base::make_optional(0UL);
+    return std::make_optional(0UL);
 
   if (descendant->children()->empty())
     return GetSizeEntryOfNode(descendant).value_or(0ul);
 
-  base::Optional<uint64_t> size;
+  std::optional<uint64_t> size;
   for (const auto& path_to_child : *descendant->children()) {
     auto c_size = AggregateSizeForDescendantNode(root, path_to_child.second);
     if (size) {
@@ -556,10 +556,10 @@
 // static
 void GraphProcessor::CalculateSizeForNode(Node* node) {
   // Get the size at the root node if it exists.
-  base::Optional<uint64_t> node_size = GetSizeEntryOfNode(node);
+  std::optional<uint64_t> node_size = GetSizeEntryOfNode(node);
 
   // Aggregate the size of all the child nodes.
-  base::Optional<uint64_t> aggregated_size;
+  std::optional<uint64_t> aggregated_size;
   for (const auto& path_to_child : *node->children()) {
     auto c_size = AggregateSizeForDescendantNode(node, path_to_child.second);
     if (aggregated_size) {
@@ -578,7 +578,7 @@
   // *aggregated_size);
 
   // Calculate the maximal size of an owner node.
-  base::Optional<uint64_t> max_owner_size;
+  std::optional<uint64_t> max_owner_size;
   for (auto* edge : *node->owned_by_edges()) {
     auto o_size = GetSizeEntryOfNode(edge->source());
     if (max_owner_size) {
@@ -625,7 +625,7 @@
 // static
 void GraphProcessor::CalculateNodeSubSizes(Node* node) {
   // Completely skip nodes with undefined size.
-  base::Optional<uint64_t> size_opt = GetSizeEntryOfNode(node);
+  std::optional<uint64_t> size_opt = GetSizeEntryOfNode(node);
   if (!size_opt)
     return;
 
@@ -669,7 +669,7 @@
 // static
 void GraphProcessor::CalculateNodeOwnershipCoefficient(Node* node) {
   // Completely skip nodes with undefined size.
-  base::Optional<uint64_t> size_opt = GetSizeEntryOfNode(node);
+  std::optional<uint64_t> size_opt = GetSizeEntryOfNode(node);
   if (!size_opt)
     return;
 
@@ -744,7 +744,7 @@
 // static
 void GraphProcessor::CalculateNodeCumulativeOwnershipCoefficient(Node* node) {
   // Completely skip nodes with undefined size.
-  base::Optional<uint64_t> size_opt = GetSizeEntryOfNode(node);
+  std::optional<uint64_t> size_opt = GetSizeEntryOfNode(node);
   if (!size_opt)
     return;
 
@@ -771,7 +771,7 @@
 void GraphProcessor::CalculateNodeEffectiveSize(Node* node) {
   // Completely skip nodes with undefined size. As a result, each node will
   // have defined effective size if and only if it has defined size.
-  base::Optional<uint64_t> size_opt = GetSizeEntryOfNode(node);
+  std::optional<uint64_t> size_opt = GetSizeEntryOfNode(node);
   if (!size_opt) {
     node->entries()->erase(kEffectiveSizeEntryName);
     return;
diff --git a/src/trace_processor/importers/memory_tracker/graph_processor_unittest.cc b/src/trace_processor/importers/memory_tracker/graph_processor_unittest.cc
index 4275b36..2a96ee7 100644
--- a/src/trace_processor/importers/memory_tracker/graph_processor_unittest.cc
+++ b/src/trace_processor/importers/memory_tracker/graph_processor_unittest.cc
@@ -71,8 +71,8 @@
     GraphProcessor::PropagateNumericsAndDiagnosticsRecursively(node);
   }
 
-  base::Optional<uint64_t> AggregateSizeForDescendantNode(Node* root,
-                                                          Node* descendant) {
+  std::optional<uint64_t> AggregateSizeForDescendantNode(Node* root,
+                                                         Node* descendant) {
     return GraphProcessor::AggregateSizeForDescendantNode(root, descendant);
   }
 
diff --git a/src/trace_processor/importers/proto/active_chrome_processes_tracker.cc b/src/trace_processor/importers/proto/active_chrome_processes_tracker.cc
index 1c20836..a689cec 100644
--- a/src/trace_processor/importers/proto/active_chrome_processes_tracker.cc
+++ b/src/trace_processor/importers/proto/active_chrome_processes_tracker.cc
@@ -31,8 +31,8 @@
   for (auto it = process_data_.GetIterator(); it; ++it) {
     UniquePid upid = it.key();
     const auto& process_data = it.value();
-    base::Optional<int64_t> last_loss_moment;
-    base::Optional<int64_t> next_no_loss_moment;
+    std::optional<int64_t> last_loss_moment;
+    std::optional<int64_t> next_no_loss_moment;
     for (int64_t metadata_ts : process_data.metadata_timestamps) {
       // Looks for a matching process descriptor in the [t - 0.2s, t + 0.2s]
       // window. The window size is somewhat arbitrary, and can be changed in
@@ -60,7 +60,7 @@
           // trace.
           next_no_loss_moment = *global_metadata_it;
         } else {
-          next_no_loss_moment = base::nullopt;
+          next_no_loss_moment = std::nullopt;
         }
       }
     }
diff --git a/src/trace_processor/importers/proto/active_chrome_processes_tracker.h b/src/trace_processor/importers/proto/active_chrome_processes_tracker.h
index 3dd1499..b4ebdc1 100644
--- a/src/trace_processor/importers/proto/active_chrome_processes_tracker.h
+++ b/src/trace_processor/importers/proto/active_chrome_processes_tracker.h
@@ -17,9 +17,9 @@
 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_ACTIVE_CHROME_PROCESSES_TRACKER_H_
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_ACTIVE_CHROME_PROCESSES_TRACKER_H_
 
+#include <optional>
 #include <set>
 #include <vector>
-#include "perfetto/ext/base/optional.h"
 
 #include "perfetto/ext/base/flat_hash_map.h"
 #include "src/trace_processor/storage/trace_storage.h"
@@ -30,9 +30,9 @@
 
 struct ProcessWithDataLoss {
   UniquePid upid;
-  // If not nullopt, the process data is reliable from this point until
+  // If not std::nullopt, the process data is reliable from this point until
   // the end of the trace.
-  base::Optional<int64_t> reliable_from;
+  std::optional<int64_t> reliable_from;
 };
 
 // Tracks ActiveProcesses metadata packets from ChromeTrackEvent,
diff --git a/src/trace_processor/importers/proto/active_chrome_processes_tracker_unittest.cc b/src/trace_processor/importers/proto/active_chrome_processes_tracker_unittest.cc
index 8917eb5..19a04c2 100644
--- a/src/trace_processor/importers/proto/active_chrome_processes_tracker_unittest.cc
+++ b/src/trace_processor/importers/proto/active_chrome_processes_tracker_unittest.cc
@@ -45,8 +45,8 @@
   tracker.AddActiveProcessMetadata(/*timestamp=*/10, /*upid=*/1);
   tracker.AddActiveProcessMetadata(/*timestamp=*/10, /*upid=*/2);
   EXPECT_THAT(tracker.GetProcessesWithDataLoss(),
-              UnorderedElementsAre(ProcessWithDataLoss{1, base::nullopt},
-                                   ProcessWithDataLoss{2, base::nullopt}));
+              UnorderedElementsAre(ProcessWithDataLoss{1, std::nullopt},
+                                   ProcessWithDataLoss{2, std::nullopt}));
 }
 
 TEST(ActiveChromeProcessesTrackerTest, InexactMatch) {
@@ -104,7 +104,7 @@
   // The second process has data loss till the end of the trace.
   EXPECT_THAT(tracker.GetProcessesWithDataLoss(),
               UnorderedElementsAre(ProcessWithDataLoss{1, 15},
-                                   ProcessWithDataLoss{2, base::nullopt}));
+                                   ProcessWithDataLoss{2, std::nullopt}));
 }
 
 }  // namespace
diff --git a/src/trace_processor/importers/proto/android_camera_event_module.h b/src/trace_processor/importers/proto/android_camera_event_module.h
index 8c0453f..88e7476 100644
--- a/src/trace_processor/importers/proto/android_camera_event_module.h
+++ b/src/trace_processor/importers/proto/android_camera_event_module.h
@@ -18,9 +18,9 @@
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_ANDROID_CAMERA_EVENT_MODULE_H_
 
 #include <cstdint>
+#include <optional>
 #include <unordered_map>
 
-#include "perfetto/ext/base/optional.h"
 #include "protos/perfetto/trace/trace_packet.pbzero.h"
 #include "src/trace_processor/importers/common/parser_types.h"
 #include "src/trace_processor/importers/proto/proto_importer_module.h"
diff --git a/src/trace_processor/importers/proto/android_probes_parser.cc b/src/trace_processor/importers/proto/android_probes_parser.cc
index 7827d50..754f30a 100644
--- a/src/trace_processor/importers/proto/android_probes_parser.cc
+++ b/src/trace_processor/importers/proto/android_probes_parser.cc
@@ -16,7 +16,8 @@
 
 #include "src/trace_processor/importers/proto/android_probes_parser.h"
 
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/traced/sys_stats_counters.h"
 #include "src/trace_processor/importers/common/args_tracker.h"
@@ -344,19 +345,19 @@
     int32_t cur_mode = static_cast<int32_t>(game_pkg.current_mode());
 
     bool is_standard_mode = false;
-    base::Optional<double> standard_downscale;
-    base::Optional<int32_t> standard_angle;
-    base::Optional<double> standard_fps;
+    std::optional<double> standard_downscale;
+    std::optional<int32_t> standard_angle;
+    std::optional<double> standard_fps;
 
     bool is_performance_mode = false;
-    base::Optional<double> perf_downscale;
-    base::Optional<int32_t> perf_angle;
-    base::Optional<double> perf_fps;
+    std::optional<double> perf_downscale;
+    std::optional<int32_t> perf_angle;
+    std::optional<double> perf_fps;
 
     bool is_battery_mode = false;
-    base::Optional<double> battery_downscale;
-    base::Optional<int32_t> battery_angle;
-    base::Optional<double> battery_fps;
+    std::optional<double> battery_downscale;
+    std::optional<int32_t> battery_angle;
+    std::optional<double> battery_fps;
 
     for (auto mode_it = game_pkg.game_mode_info(); mode_it; ++mode_it) {
       protos::pbzero::AndroidGameInterventionList_GameModeInfo::Decoder
@@ -407,7 +408,7 @@
   for (auto it = properties.values(); it; ++it) {
     protos::pbzero::AndroidSystemProperty::PropertyValue::Decoder kv(*it);
     base::StringView name(kv.name());
-    base::Optional<StringId> mapped_name_id;
+    std::optional<StringId> mapped_name_id;
 
     if (name == "debug.tracing.device_state") {
       auto state = kv.value();
@@ -423,7 +424,7 @@
                name == "debug.tracing.mcc" || name == "debug.tracing.mnc") {
       StringId name_id = context_->storage->InternString(
           name.substr(strlen("debug.tracing.")));
-      base::Optional<int32_t> state =
+      std::optional<int32_t> state =
           base::StringToInt32(kv.value().ToStdString());
       if (state) {
         TrackId track =
@@ -438,7 +439,7 @@
       mapped_name_id = plug_type_id_;
     }
     if (mapped_name_id) {
-      base::Optional<int32_t> state =
+      std::optional<int32_t> state =
           base::StringToInt32(kv.value().ToStdString());
       if (state) {
         TrackId track =
diff --git a/src/trace_processor/importers/proto/android_probes_tracker.h b/src/trace_processor/importers/proto/android_probes_tracker.h
index e5e2469..72ccae2 100644
--- a/src/trace_processor/importers/proto/android_probes_tracker.h
+++ b/src/trace_processor/importers/proto/android_probes_tracker.h
@@ -17,9 +17,9 @@
 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_ANDROID_PROBES_TRACKER_H_
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_ANDROID_PROBES_TRACKER_H_
 
+#include <optional>
 #include <set>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 
 #include "src/trace_processor/storage/trace_storage.h"
@@ -66,12 +66,12 @@
     seen_packages_.emplace(std::move(package_name));
   }
 
-  base::Optional<TrackId> GetPowerRailTrack(uint32_t index) {
+  std::optional<TrackId> GetPowerRailTrack(uint32_t index) {
     if (index >= power_rail_tracks_.size())
-      return base::nullopt;
+      return std::nullopt;
     TrackId track_id = power_rail_tracks_[index];
-    return track_id == kInvalidTrackId ? base::nullopt
-                                       : base::make_optional(track_id);
+    return track_id == kInvalidTrackId ? std::nullopt
+                                       : std::make_optional(track_id);
   }
 
   void SetPowerRailTrack(uint32_t index, TrackId track_id) {
@@ -80,12 +80,12 @@
     power_rail_tracks_[index] = track_id;
   }
 
-  base::Optional<EnergyConsumerSpecs> GetEnergyBreakdownDescriptor(
+  std::optional<EnergyConsumerSpecs> GetEnergyBreakdownDescriptor(
       int32_t consumer_id) {
     auto it = energy_consumer_descriptors_.find(consumer_id);
     // Didn't receive the descriptor
     if (it == energy_consumer_descriptors_.end()) {
-      return base::nullopt;
+      return std::nullopt;
     }
     return it->second;
   }
@@ -105,14 +105,14 @@
         EnergyConsumerSpecs{name, type, ordinal};
   }
 
-  base::Optional<EntityStateDescriptor> GetEntityStateDescriptor(
+  std::optional<EntityStateDescriptor> GetEntityStateDescriptor(
       int32_t entity_id,
       int32_t state_id) {
     uint64_t id = EntityStateKey(entity_id, state_id);
     auto it = entity_state_descriptors_.find(id);
     // Didn't receive the descriptor
     if (it == entity_state_descriptors_.end()) {
-      return base::nullopt;
+      return std::nullopt;
     }
     return it->second;
   }
diff --git a/src/trace_processor/importers/proto/chrome_string_lookup.h b/src/trace_processor/importers/proto/chrome_string_lookup.h
index 23f8eca..c1446e5 100644
--- a/src/trace_processor/importers/proto/chrome_string_lookup.h
+++ b/src/trace_processor/importers/proto/chrome_string_lookup.h
@@ -19,9 +19,9 @@
 
 #include <map>
 
+#include <optional>
 #include "src/trace_processor/storage/trace_storage.h"
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 
 namespace perfetto {
diff --git a/src/trace_processor/importers/proto/content_analyzer.cc b/src/trace_processor/importers/proto/content_analyzer.cc
index a225f09..0123c44 100644
--- a/src/trace_processor/importers/proto/content_analyzer.cc
+++ b/src/trace_processor/importers/proto/content_analyzer.cc
@@ -70,7 +70,7 @@
         path_ids;
     for (auto sample = annotated_map.value().GetIterator(); sample; ++sample) {
       std::string path_string;
-      base::Optional<tables::ExperimentalProtoPathTable::Id> previous_path_id;
+      std::optional<tables::ExperimentalProtoPathTable::Id> previous_path_id;
       util::SizeProfileComputer::FieldPath path;
       for (const auto& field : sample.key()) {
         if (field.has_field_name()) {
diff --git a/src/trace_processor/importers/proto/frame_timeline_event_parser.cc b/src/trace_processor/importers/proto/frame_timeline_event_parser.cc
index 0b3e84e..9afec02 100644
--- a/src/trace_processor/importers/proto/frame_timeline_event_parser.cc
+++ b/src/trace_processor/importers/proto/frame_timeline_event_parser.cc
@@ -302,7 +302,7 @@
     actual_row.jank_tag = jank_tag_none_id_;
   }
 
-  base::Optional<SliceId> opt_slice_id = context_->slice_tracker->BeginTyped(
+  std::optional<SliceId> opt_slice_id = context_->slice_tracker->BeginTyped(
       context_->storage->mutable_actual_frame_timeline_slice_table(),
       actual_row,
       [this, token, jank_type, present_type, prediction_type,
@@ -508,7 +508,7 @@
       is_buffer = context_->storage->InternString("No");
   }
 
-  base::Optional<SliceId> opt_slice_id = context_->slice_tracker->BeginTyped(
+  std::optional<SliceId> opt_slice_id = context_->slice_tracker->BeginTyped(
       context_->storage->mutable_actual_frame_timeline_slice_table(),
       actual_row,
       [this, jank_type, present_type, token, layer_name_id, display_frame_token,
diff --git a/src/trace_processor/importers/proto/gpu_event_parser.cc b/src/trace_processor/importers/proto/gpu_event_parser.cc
index 377b5eb..56bc165 100644
--- a/src/trace_processor/importers/proto/gpu_event_parser.cc
+++ b/src/trace_processor/importers/proto/gpu_event_parser.cc
@@ -280,17 +280,17 @@
   }
   ++gpu_hw_queue_counter_;
 }
-base::Optional<std::string> GpuEventParser::FindDebugName(
+std::optional<std::string> GpuEventParser::FindDebugName(
     int32_t vk_object_type,
     uint64_t vk_handle) const {
   auto map = debug_marker_names_.find(vk_object_type);
   if (map == debug_marker_names_.end()) {
-    return base::nullopt;
+    return std::nullopt;
   }
 
   auto name = map->second.find(vk_handle);
   if (name == map->second.end()) {
-    return base::nullopt;
+    return std::nullopt;
   } else {
     return name->second;
   }
diff --git a/src/trace_processor/importers/proto/gpu_event_parser.h b/src/trace_processor/importers/proto/gpu_event_parser.h
index b79b65f..e2eaac8 100644
--- a/src/trace_processor/importers/proto/gpu_event_parser.h
+++ b/src/trace_processor/importers/proto/gpu_event_parser.h
@@ -17,9 +17,9 @@
 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_GPU_EVENT_PARSER_H_
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_GPU_EVENT_PARSER_H_
 
+#include <optional>
 #include <vector>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_writer.h"
 #include "perfetto/protozero/field.h"
 #include "protos/perfetto/trace/android/gpu_mem_event.pbzero.h"
@@ -82,8 +82,8 @@
   void InsertGpuTrack(
       const protos::pbzero::
           GpuRenderStageEvent_Specifications_Description_Decoder& hw_queue);
-  base::Optional<std::string> FindDebugName(int32_t vk_object_type,
-                                            uint64_t vk_handle) const;
+  std::optional<std::string> FindDebugName(int32_t vk_object_type,
+                                           uint64_t vk_handle) const;
   const StringId ParseRenderSubpasses(
       const protos::pbzero::GpuRenderStageEvent_Decoder& event) const;
 
@@ -94,7 +94,7 @@
   // For GpuRenderStageEvent
   const StringId description_id_;
   const StringId gpu_render_stage_scope_id_;
-  std::vector<perfetto::base::Optional<TrackId>> gpu_hw_queue_ids_;
+  std::vector<std::optional<TrackId>> gpu_hw_queue_ids_;
   size_t gpu_hw_queue_counter_ = 0;
   // Map of stage ID -> pair(stage name, stage description)
   std::vector<std::pair<StringId, StringId>> gpu_render_stage_ids_;
diff --git a/src/trace_processor/importers/proto/graphics_frame_event_parser.cc b/src/trace_processor/importers/proto/graphics_frame_event_parser.cc
index aa6742e..11808a4 100644
--- a/src/trace_processor/importers/proto/graphics_frame_event_parser.cc
+++ b/src/trace_processor/importers/proto/graphics_frame_event_parser.cc
@@ -154,7 +154,7 @@
       row.acquire_to_latch_time = latch_ts - acquire_ts;
       row.latch_to_present_time = timestamp - latch_ts;
     }
-    base::Optional<SliceId> opt_slice_id =
+    std::optional<SliceId> opt_slice_id =
         context_->slice_tracker->ScopedTyped(graphics_frame_slice_table, row);
     if (event.type() == GraphicsFrameEvent::DEQUEUE) {
       if (opt_slice_id) {
diff --git a/src/trace_processor/importers/proto/graphics_frame_event_parser.h b/src/trace_processor/importers/proto/graphics_frame_event_parser.h
index 957e6ad..2d37612 100644
--- a/src/trace_processor/importers/proto/graphics_frame_event_parser.h
+++ b/src/trace_processor/importers/proto/graphics_frame_event_parser.h
@@ -17,9 +17,9 @@
 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_GRAPHICS_FRAME_EVENT_PARSER_H_
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_GRAPHICS_FRAME_EVENT_PARSER_H_
 
+#include <optional>
 #include <vector>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_writer.h"
 #include "perfetto/protozero/field.h"
 #include "src/trace_processor/importers/common/args_tracker.h"
diff --git a/src/trace_processor/importers/proto/heap_graph_module.cc b/src/trace_processor/importers/proto/heap_graph_module.cc
index 0fe7506..ad2b806 100644
--- a/src/trace_processor/importers/proto/heap_graph_module.cc
+++ b/src/trace_processor/importers/proto/heap_graph_module.cc
@@ -239,7 +239,7 @@
 
     StringId kind = context_->storage->InternString(
         HeapGraphTypeKindToString(entry.kind()));
-    base::Optional<uint64_t> location_id;
+    std::optional<uint64_t> location_id;
     if (entry.has_location_id())
       location_id = entry.location_id();
 
@@ -289,7 +289,7 @@
 }
 
 void HeapGraphModule::DeobfuscateClass(
-    base::Optional<StringId> package_name_id,
+    std::optional<StringId> package_name_id,
     StringId obfuscated_class_name_id,
     const protos::pbzero::ObfuscatedClass::Decoder& cls) {
   auto* heap_graph_tracker = HeapGraphTracker::GetOrCreate(context_);
@@ -320,7 +320,7 @@
   auto* heap_graph_tracker = HeapGraphTracker::GetOrCreate(context_);
   protos::pbzero::DeobfuscationMapping::Decoder deobfuscation_mapping(
       blob.data, blob.size);
-  base::Optional<StringId> package_name_id;
+  std::optional<StringId> package_name_id;
   if (deobfuscation_mapping.package_name().size > 0) {
     package_name_id = context_->storage->string_pool().GetId(
         deobfuscation_mapping.package_name());
@@ -340,7 +340,7 @@
       // TODO(b/153552977): Remove this work-around for legacy traces.
       // For traces without location information, deobfuscate all matching
       // classes.
-      DeobfuscateClass(base::nullopt, *obfuscated_class_name_id, cls);
+      DeobfuscateClass(std::nullopt, *obfuscated_class_name_id, cls);
       if (package_name_id) {
         DeobfuscateClass(package_name_id, *obfuscated_class_name_id, cls);
       }
diff --git a/src/trace_processor/importers/proto/heap_graph_module.h b/src/trace_processor/importers/proto/heap_graph_module.h
index 502eab1..42665ef 100644
--- a/src/trace_processor/importers/proto/heap_graph_module.h
+++ b/src/trace_processor/importers/proto/heap_graph_module.h
@@ -42,7 +42,7 @@
  private:
   void ParseHeapGraph(uint32_t seq_id, int64_t ts, protozero::ConstBytes);
   void ParseDeobfuscationMapping(protozero::ConstBytes);
-  void DeobfuscateClass(base::Optional<StringPool::Id> package_name_id,
+  void DeobfuscateClass(std::optional<StringPool::Id> package_name_id,
                         StringPool::Id obfuscated_class_id,
                         const protos::pbzero::ObfuscatedClass::Decoder& cls);
 
diff --git a/src/trace_processor/importers/proto/heap_graph_tracker.cc b/src/trace_processor/importers/proto/heap_graph_tracker.cc
index b709d33..e337113 100644
--- a/src/trace_processor/importers/proto/heap_graph_tracker.cc
+++ b/src/trace_processor/importers/proto/heap_graph_tracker.cc
@@ -16,8 +16,9 @@
 
 #include "src/trace_processor/importers/proto/heap_graph_tracker.h"
 
+#include <optional>
+
 #include "perfetto/base/flat_set.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "src/trace_processor/importers/proto/profiler_util.h"
@@ -42,7 +43,7 @@
 void ForReferenceSet(TraceStorage* storage,
                      ObjectTable::ConstRowReference object,
                      F fn) {
-  base::Optional<uint32_t> reference_set_id = object.reference_set_id();
+  std::optional<uint32_t> reference_set_id = object.reference_set_id();
   if (!reference_set_id)
     return;
 
@@ -62,13 +63,13 @@
       *storage->heap_graph_class_table().FindById(object.type_id());
 
   StringId kind = cls_row_ref.kind();
-  base::Optional<StringId> weakref_kind =
+  std::optional<StringId> weakref_kind =
       storage->string_pool().GetId("KIND_WEAK_REFERENCE");
-  base::Optional<StringId> softref_kind =
+  std::optional<StringId> softref_kind =
       storage->string_pool().GetId("KIND_SOFT_REFERENCE");
-  base::Optional<StringId> finalizerref_kind =
+  std::optional<StringId> finalizerref_kind =
       storage->string_pool().GetId("KIND_FINALIZER_REFERENCE");
-  base::Optional<StringId> phantomref_kind =
+  std::optional<StringId> phantomref_kind =
       storage->string_pool().GetId("KIND_PHANTOM_REFERENCE");
 
   if ((weakref_kind && kind == *weakref_kind) ||
@@ -94,7 +95,7 @@
 
 struct ClassDescriptor {
   StringId name;
-  base::Optional<StringId> location;
+  std::optional<StringId> location;
 
   bool operator<(const ClassDescriptor& other) const {
     return std::tie(name, location) < std::tie(other.name, other.location);
@@ -109,16 +110,16 @@
   return {type_row_ref.name(), type_row_ref.location()};
 }
 
-base::Optional<ObjectTable::Id> GetReferredObj(const TraceStorage& storage,
-                                               uint32_t ref_set_id,
-                                               const std::string& field_name) {
+std::optional<ObjectTable::Id> GetReferredObj(const TraceStorage& storage,
+                                              uint32_t ref_set_id,
+                                              const std::string& field_name) {
   const auto& refs_tbl = storage.heap_graph_reference_table();
 
   auto refs_it = refs_tbl.FilterToIterator(
       {refs_tbl.reference_set_id().eq(ref_set_id),
        refs_tbl.field_name().eq(NullTermStringView(field_name))});
   if (!refs_it) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return refs_it.owned_id();
 }
@@ -225,7 +226,7 @@
   }
 }
 
-base::Optional<base::StringView> GetStaticClassTypeName(base::StringView type) {
+std::optional<base::StringView> GetStaticClassTypeName(base::StringView type) {
   static const base::StringView kJavaClassTemplate("java.lang.Class<");
   if (!type.empty() && type.at(type.size() - 1) == '>' &&
       type.substr(0, kJavaClassTemplate.size()) == kJavaClassTemplate) {
@@ -316,10 +317,10 @@
                                             sequence_state->current_ts,
                                             -1,
                                             0,
-                                            /*reference_set_id=*/base::nullopt,
+                                            /*reference_set_id=*/std::nullopt,
                                             /*reachable=*/0,
                                             {},
-                                            /*root_type=*/base::nullopt,
+                                            /*root_type=*/std::nullopt,
                                             /*root_distance*/ -1});
     bool inserted;
     std::tie(ptr, inserted) = sequence_state->object_id_to_db_row.Insert(
@@ -335,7 +336,7 @@
   auto* ptr = sequence_state->type_id_to_db_row.Find(type_id);
   if (!ptr) {
     auto id_and_row =
-        class_table->Insert({StringId(), base::nullopt, base::nullopt});
+        class_table->Insert({StringId(), std::nullopt, std::nullopt});
     bool inserted;
     std::tie(ptr, inserted) = sequence_state->type_id_to_db_row.Insert(
         type_id, id_and_row.row_number);
@@ -377,7 +378,7 @@
   for (size_t i = 0; i < obj.referred_objects.size(); ++i) {
     uint64_t owned_object_id = obj.referred_objects[i];
     // This is true for unset reference fields.
-    base::Optional<ObjectTable::RowReference> owned_row_ref;
+    std::optional<ObjectTable::RowReference> owned_row_ref;
     if (owned_object_id != 0)
       owned_row_ref = GetOrInsertObject(&sequence_state, owned_object_id);
 
@@ -385,11 +386,11 @@
         storage_->mutable_heap_graph_reference_table()->Insert(
             {reference_set_id,
              owner_id,
-             owned_row_ref ? base::make_optional(owned_row_ref->id())
-                           : base::nullopt,
+             owned_row_ref ? std::make_optional(owned_row_ref->id())
+                           : std::nullopt,
              {},
              {},
-             /*deobfuscated_field_name=*/base::nullopt});
+             /*deobfuscated_field_name=*/std::nullopt});
     if (!obj.field_name_ids.empty()) {
       sequence_state.references_for_field_name_id[obj.field_name_ids[i]]
           .push_back(ref_id_and_row.row_number);
@@ -431,7 +432,7 @@
 void HeapGraphTracker::AddInternedType(uint32_t seq_id,
                                        uint64_t intern_id,
                                        StringId strid,
-                                       base::Optional<uint64_t> location_id,
+                                       std::optional<uint64_t> location_id,
                                        uint64_t object_size,
                                        std::vector<uint64_t> field_name_ids,
                                        uint64_t superclass_id,
@@ -534,7 +535,7 @@
   for (const auto& p : sequence_state.interned_types) {
     uint64_t id = p.first;
     const InternedType& interned_type = p.second;
-    base::Optional<StringId> location_name;
+    std::optional<StringId> location_name;
     if (interned_type.location_id) {
       auto it = sequence_state.interned_location_names.find(
           *interned_type.location_id);
@@ -622,9 +623,9 @@
     base::StringView normalized_type =
         NormalizeTypeName(storage_->GetString(interned_type.name));
 
-    base::Optional<StringId> class_package;
+    std::optional<StringId> class_package;
     if (location_name) {
-      base::Optional<std::string> package_name =
+      std::optional<std::string> package_name =
           PackageFromLocation(storage_, storage_->GetString(*location_name));
       if (package_name) {
         class_package = storage_->InternString(base::StringView(*package_name));
@@ -677,10 +678,10 @@
   sequence_state_.erase(seq_id);
 }
 
-base::Optional<ObjectTable::Id> HeapGraphTracker::GetReferenceByFieldName(
+std::optional<ObjectTable::Id> HeapGraphTracker::GetReferenceByFieldName(
     ObjectTable::Id obj,
     StringId field) {
-  base::Optional<ObjectTable::Id> referred;
+  std::optional<ObjectTable::Id> referred;
   auto obj_row_ref = *storage_->heap_graph_object_table().FindById(obj);
   ForReferenceSet(storage_, obj_row_ref,
                   [&](ReferenceTable::RowReference ref) -> bool {
@@ -732,16 +733,16 @@
          objects_tbl.graph_sample_ts().eq(seq.current_ts)});
     for (; obj_it; ++obj_it) {
       ObjectTable::Id cleaner_obj_id = obj_it.id();
-      base::Optional<ObjectTable::Id> referent_id =
+      std::optional<ObjectTable::Id> referent_id =
           GetReferenceByFieldName(cleaner_obj_id, referent_str_id_);
-      base::Optional<ObjectTable::Id> thunk_id =
+      std::optional<ObjectTable::Id> thunk_id =
           GetReferenceByFieldName(cleaner_obj_id, cleaner_thunk_str_id_);
 
       if (!referent_id || !thunk_id) {
         continue;
       }
 
-      base::Optional<ObjectTable::Id> next_id =
+      std::optional<ObjectTable::Id> next_id =
           GetReferenceByFieldName(cleaner_obj_id, cleaner_next_str_id_);
       if (next_id.has_value() && *next_id == cleaner_obj_id) {
         // sun.misc.Cleaner.next points to the sun.misc.Cleaner: this means
@@ -753,7 +754,7 @@
   }
 
   for (const auto& cleaner : cleaners) {
-    base::Optional<ObjectTable::Id> this0 =
+    std::optional<ObjectTable::Id> this0 =
         GetReferenceByFieldName(cleaner.thunk, cleaner_thunk_this0_str_id_);
     if (!this0) {
       continue;
@@ -844,14 +845,14 @@
     ClassTable::Id type_id = object_row_ref.type_id();
 
     auto type_row_ref = *storage->heap_graph_class_table().FindById(type_id);
-    base::Optional<StringId> opt_class_name_id =
+    std::optional<StringId> opt_class_name_id =
         type_row_ref.deobfuscated_name();
     if (!opt_class_name_id) {
       opt_class_name_id = type_row_ref.name();
     }
     PERFETTO_CHECK(opt_class_name_id);
     StringId class_name_id = *opt_class_name_id;
-    base::Optional<StringId> root_type = object_row_ref.root_type();
+    std::optional<StringId> root_type = object_row_ref.root_type();
     if (root_type) {
       class_name_id = storage->InternString(base::StringView(
           storage->GetString(class_name_id).ToStdString() + " [" +
@@ -957,7 +958,7 @@
       alloc_row.cumulative_count = 1;
       alloc_row.size = 1;
       alloc_row.cumulative_size = 1;
-      alloc_row.parent_id = base::nullopt;
+      alloc_row.parent_id = std::nullopt;
       tbl->Insert(alloc_row);
       return tbl;
     }
@@ -994,7 +995,7 @@
   for (size_t i = 1; i < init_path.nodes.size(); ++i) {
     const PathFromRoot::Node& node = init_path.nodes[i];
     PERFETTO_CHECK(node.parent_id < i);
-    base::Optional<FlamegraphId> parent_id;
+    std::optional<FlamegraphId> parent_id;
     if (node.parent_id != 0)
       parent_id = node_to_id[node.parent_id];
     const uint32_t depth = node.depth;
diff --git a/src/trace_processor/importers/proto/heap_graph_tracker.h b/src/trace_processor/importers/proto/heap_graph_tracker.h
index 6fd4fda..c2f184f 100644
--- a/src/trace_processor/importers/proto/heap_graph_tracker.h
+++ b/src/trace_processor/importers/proto/heap_graph_tracker.h
@@ -18,11 +18,11 @@
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_HEAP_GRAPH_TRACKER_H_
 
 #include <map>
+#include <optional>
 #include <set>
 #include <utility>
 #include <vector>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 
 #include "protos/perfetto/trace/profiling/heap_graph.pbzero.h"
@@ -64,7 +64,7 @@
                       tables::HeapGraphObjectTable::RowReference,
                       PathFromRoot* path);
 
-base::Optional<base::StringView> GetStaticClassTypeName(base::StringView type);
+std::optional<base::StringView> GetStaticClassTypeName(base::StringView type);
 size_t NumberOfArrays(base::StringView type);
 NormalizedType GetNormalizedType(base::StringView type);
 base::StringView NormalizeTypeName(base::StringView type);
@@ -85,7 +85,7 @@
 
     // If this object is an instance of `libcore.util.NativeAllocationRegistry`,
     // this is the value of its `size` field.
-    base::Optional<int64_t> native_allocation_registry_size;
+    std::optional<int64_t> native_allocation_registry_size;
   };
 
   struct SourceRoot {
@@ -108,7 +108,7 @@
   void AddInternedType(uint32_t seq_id,
                        uint64_t intern_id,
                        StringId strid,
-                       base::Optional<uint64_t> location_id,
+                       std::optional<uint64_t> location_id,
                        uint64_t object_size,
                        std::vector<uint64_t> field_name_ids,
                        uint64_t superclass_id,
@@ -128,7 +128,7 @@
   ~HeapGraphTracker() override;
 
   const std::vector<tables::HeapGraphClassTable::RowNumber>* RowsForType(
-      base::Optional<StringId> package_name,
+      std::optional<StringId> package_name,
       StringId type_name) const {
     auto it = class_to_rows_.find(std::make_pair(package_name, type_name));
     if (it == class_to_rows_.end())
@@ -156,7 +156,7 @@
   };
   struct InternedType {
     StringId name;
-    base::Optional<uint64_t> location_id;
+    std::optional<uint64_t> location_id;
     uint64_t object_size;
     std::vector<uint64_t> field_name_ids;
     uint64_t superclass_id;
@@ -192,7 +192,7 @@
     std::map<tables::HeapGraphClassTable::Id,
              std::vector<tables::HeapGraphObjectTable::RowNumber>>
         deferred_reference_objects_for_type_;
-    base::Optional<uint64_t> prev_index;
+    std::optional<uint64_t> prev_index;
     // For most objects, we need not store the size in the object's message
     // itself, because all instances of the type have the same type. In this
     // case, we defer setting self_size in the table until we process the class
@@ -220,7 +220,7 @@
   bool IsTruncated(UniquePid upid, int64_t ts);
 
   // Returns the object pointed to by `field` in `obj`.
-  base::Optional<tables::HeapGraphObjectTable::Id> GetReferenceByFieldName(
+  std::optional<tables::HeapGraphObjectTable::Id> GetReferenceByFieldName(
       tables::HeapGraphObjectTable::Id obj,
       StringId field);
 
@@ -234,14 +234,14 @@
   TraceStorage* const storage_;
   std::map<uint32_t, SequenceState> sequence_state_;
 
-  std::map<std::pair<base::Optional<StringId>, StringId>,
+  std::map<std::pair<std::optional<StringId>, StringId>,
            std::vector<tables::HeapGraphClassTable::RowNumber>>
       class_to_rows_;
   base::FlatHashMap<StringId,
                     std::vector<tables::HeapGraphReferenceTable::RowNumber>>
       field_to_rows_;
 
-  std::map<std::pair<base::Optional<StringId>, StringId>, StringId>
+  std::map<std::pair<std::optional<StringId>, StringId>, StringId>
       deobfuscation_mapping_;
   std::map<std::pair<UniquePid, int64_t>,
            std::set<tables::HeapGraphObjectTable::RowNumber>>
diff --git a/src/trace_processor/importers/proto/heap_graph_tracker_unittest.cc b/src/trace_processor/importers/proto/heap_graph_tracker_unittest.cc
index 491082a..15be4ac 100644
--- a/src/trace_processor/importers/proto/heap_graph_tracker_unittest.cc
+++ b/src/trace_processor/importers/proto/heap_graph_tracker_unittest.cc
@@ -174,7 +174,7 @@
   const auto& class_table = context.storage->heap_graph_class_table();
   size_t count_bitmaps = 0;
   for (uint32_t obj_row = 0; obj_row < objs_table.row_count(); ++obj_row) {
-    base::Optional<uint32_t> class_row =
+    std::optional<uint32_t> class_row =
         class_table.id().IndexOf(objs_table.type_id()[obj_row]);
     ASSERT_TRUE(class_row.has_value());
     if (context.storage->string_pool().Get(class_table.name()[*class_row]) ==
diff --git a/src/trace_processor/importers/proto/heap_profile_tracker.h b/src/trace_processor/importers/proto/heap_profile_tracker.h
index 03b1d7b..5ed5394 100644
--- a/src/trace_processor/importers/proto/heap_profile_tracker.h
+++ b/src/trace_processor/importers/proto/heap_profile_tracker.h
@@ -17,10 +17,10 @@
 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_HEAP_PROFILE_TRACKER_H_
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_HEAP_PROFILE_TRACKER_H_
 
+#include <optional>
 #include <set>
 #include <unordered_map>
 
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/importers/proto/stack_profile_tracker.h"
 #include "src/trace_processor/storage/trace_storage.h"
 
@@ -112,7 +112,7 @@
              tables::HeapProfileAllocationTable::Row>
         free_correction;
 
-    base::Optional<uint64_t> prev_index;
+    std::optional<uint64_t> prev_index;
   };
   std::map<uint32_t, SequenceState> sequence_state_;
   TraceProcessorContext* const context_;
diff --git a/src/trace_processor/importers/proto/heap_profile_tracker_unittest.cc b/src/trace_processor/importers/proto/heap_profile_tracker_unittest.cc
index 0ac2608..558ad91 100644
--- a/src/trace_processor/importers/proto/heap_profile_tracker_unittest.cc
+++ b/src/trace_processor/importers/proto/heap_profile_tracker_unittest.cc
@@ -174,17 +174,17 @@
   EXPECT_EQ(depth[0], 0u);
   EXPECT_EQ(depth[1], 1u);
 
-  EXPECT_EQ(parent_id[0], base::nullopt);
+  EXPECT_EQ(parent_id[0], std::nullopt);
   EXPECT_EQ(parent_id[1], CallsiteId{0});
 
   EXPECT_EQ(frame_id[0], FrameId{0});
   EXPECT_EQ(frame_id[1], FrameId{0});
 }
 
-base::Optional<CallsiteId> FindCallstack(const TraceStorage& storage,
-                                         int64_t depth,
-                                         base::Optional<CallsiteId> parent,
-                                         FrameId frame_id) {
+std::optional<CallsiteId> FindCallstack(const TraceStorage& storage,
+                                        int64_t depth,
+                                        std::optional<CallsiteId> parent,
+                                        FrameId frame_id) {
   const auto& callsites = storage.stack_profile_callsite_table();
   for (uint32_t i = 0; i < callsites.row_count(); ++i) {
     if (callsites.depth()[i] == depth && callsites.parent_id()[i] == parent &&
@@ -192,7 +192,7 @@
       return callsites.id()[i];
     }
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 TEST(HeapProfileTrackerTest, SourceMappingPath) {
@@ -224,7 +224,7 @@
   spt->AddMapping(0, mapping);
   hpt->CommitAllocations(kDefaultSequence, spt.get(), nullptr);
   auto foo_bar_id = context.storage->string_pool().GetId("/foo/bar");
-  ASSERT_NE(foo_bar_id, base::nullopt);
+  ASSERT_NE(foo_bar_id, std::nullopt);
   EXPECT_THAT(context.storage->stack_profile_mapping_table().name()[0],
               *foo_bar_id);
 }
@@ -331,12 +331,12 @@
   hpt->CommitAllocations(kDefaultSequence, spt.get(), nullptr);
 
   for (size_t i = 0; i < base::ArraySize(callstacks); ++i) {
-    base::Optional<CallsiteId> parent;
+    std::optional<CallsiteId> parent;
     const SequenceStackProfileTracker::SourceCallstack& callstack =
         callstacks[i];
     for (size_t depth = 0; depth < callstack.size(); ++depth) {
       auto frame_id = spt->GetDatabaseFrameIdForTesting(callstack[depth]);
-      base::Optional<CallsiteId> self = FindCallstack(
+      std::optional<CallsiteId> self = FindCallstack(
           *context.storage, static_cast<int64_t>(depth), parent, frame_id);
       ASSERT_TRUE(self.has_value());
       parent = self;
diff --git a/src/trace_processor/importers/proto/memory_tracker_snapshot_parser.cc b/src/trace_processor/importers/proto/memory_tracker_snapshot_parser.cc
index a308351..c4eeeff 100644
--- a/src/trace_processor/importers/proto/memory_tracker_snapshot_parser.cc
+++ b/src/trace_processor/importers/proto/memory_tracker_snapshot_parser.cc
@@ -228,17 +228,17 @@
     ProcessMemorySnapshotId& proc_snapshot_row_id,
     IdNodeMap& id_node_map) {
   EmitMemorySnapshotNodeRowsRecursively(root_node_graph, std::string(),
-                                        base::nullopt, proc_snapshot_row_id,
+                                        std::nullopt, proc_snapshot_row_id,
                                         id_node_map);
 }
 
 void MemoryTrackerSnapshotParser::EmitMemorySnapshotNodeRowsRecursively(
     GlobalNodeGraph::Node& node,
     const std::string& path,
-    base::Optional<tables::MemorySnapshotNodeTable::Id> parent_node_row_id,
+    std::optional<tables::MemorySnapshotNodeTable::Id> parent_node_row_id,
     ProcessMemorySnapshotId& proc_snapshot_row_id,
     IdNodeMap& id_node_map) {
-  base::Optional<tables::MemorySnapshotNodeTable::Id> node_id;
+  std::optional<tables::MemorySnapshotNodeTable::Id> node_id;
   // Skip emitting the root node into the tables - it is not a real node.
   if (!path.empty()) {
     node_id = EmitNode(node, path, parent_node_row_id, proc_snapshot_row_id,
@@ -257,11 +257,11 @@
   }
 }
 
-base::Optional<tables::MemorySnapshotNodeTable::Id>
+std::optional<tables::MemorySnapshotNodeTable::Id>
 MemoryTrackerSnapshotParser::EmitNode(
     const GlobalNodeGraph::Node& node,
     const std::string& path,
-    base::Optional<tables::MemorySnapshotNodeTable::Id> parent_node_row_id,
+    std::optional<tables::MemorySnapshotNodeTable::Id> parent_node_row_id,
     ProcessMemorySnapshotId& proc_snapshot_row_id,
     IdNodeMap& id_node_map) {
   tables::MemorySnapshotNodeTable::Row node_row;
diff --git a/src/trace_processor/importers/proto/memory_tracker_snapshot_parser.h b/src/trace_processor/importers/proto/memory_tracker_snapshot_parser.h
index 32119c2..deec274 100644
--- a/src/trace_processor/importers/proto/memory_tracker_snapshot_parser.h
+++ b/src/trace_processor/importers/proto/memory_tracker_snapshot_parser.h
@@ -90,7 +90,7 @@
   void EmitMemorySnapshotNodeRowsRecursively(
       GlobalNodeGraph::Node& node,
       const std::string&,
-      base::Optional<tables::MemorySnapshotNodeTable::Id> parent_node_row_id,
+      std::optional<tables::MemorySnapshotNodeTable::Id> parent_node_row_id,
       ProcessMemorySnapshotId& proc_snapshot_row_id,
       IdNodeMap& id_node_map);
 
@@ -99,10 +99,10 @@
   // ProcessMemorySnapshotId |proc_snapshot_row_id|. Generates map of
   // MemoryAllocatorNodeId and MemorySnapshotNodeTable::Id |id_node_map| which
   // is used at time of filling out of MemorySnapshotEdgeTable.
-  base::Optional<tables::MemorySnapshotNodeTable::Id> EmitNode(
+  std::optional<tables::MemorySnapshotNodeTable::Id> EmitNode(
       const GlobalNodeGraph::Node& node,
       const std::string& path,
-      base::Optional<tables::MemorySnapshotNodeTable::Id> parent_node_row_id,
+      std::optional<tables::MemorySnapshotNodeTable::Id> parent_node_row_id,
       ProcessMemorySnapshotId& proc_snapshot_row_id,
       IdNodeMap& id_node_map);
 
diff --git a/src/trace_processor/importers/proto/network_trace_module.cc b/src/trace_processor/importers/proto/network_trace_module.cc
index 1ea1ca7..321152e 100644
--- a/src/trace_processor/importers/proto/network_trace_module.cc
+++ b/src/trace_processor/importers/proto/network_trace_module.cc
@@ -157,7 +157,7 @@
   StringId title_id = kNullStringId;
   if (evt.uid() > 0) {
     const auto& package_list = context_->storage->package_list_table();
-    base::Optional<uint32_t> pkg_row = package_list.uid().IndexOf(evt.uid());
+    std::optional<uint32_t> pkg_row = package_list.uid().IndexOf(evt.uid());
     if (pkg_row) {
       title_id = package_list.package_name()[*pkg_row];
     }
diff --git a/src/trace_processor/importers/proto/packet_sequence_state_generation.h b/src/trace_processor/importers/proto/packet_sequence_state_generation.h
index c3dda05..9c7aa5a 100644
--- a/src/trace_processor/importers/proto/packet_sequence_state_generation.h
+++ b/src/trace_processor/importers/proto/packet_sequence_state_generation.h
@@ -17,9 +17,9 @@
 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_PACKET_SEQUENCE_STATE_GENERATION_H_
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_PACKET_SEQUENCE_STATE_GENERATION_H_
 
+#include <optional>
 #include <unordered_map>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/trace_processor/ref_counted.h"
 #include "src/trace_processor/util/interned_message_view.h"
 
@@ -106,7 +106,7 @@
   PacketSequenceState* state_;
   size_t generation_index_;
   InternedFieldMap interned_data_;
-  base::Optional<InternedMessageView> trace_packet_defaults_;
+  std::optional<InternedMessageView> trace_packet_defaults_;
 };
 
 }  // namespace trace_processor
diff --git a/src/trace_processor/importers/proto/perf_sample_tracker.cc b/src/trace_processor/importers/proto/perf_sample_tracker.cc
index aad2013..0105985 100644
--- a/src/trace_processor/importers/proto/perf_sample_tracker.cc
+++ b/src/trace_processor/importers/proto/perf_sample_tracker.cc
@@ -135,7 +135,7 @@
   if (cpu_it != seq_state->per_cpu.end())
     return {seq_state->perf_session_id, cpu_it->second.timebase_track_id};
 
-  base::Optional<PerfSampleDefaults::Decoder> perf_defaults;
+  std::optional<PerfSampleDefaults::Decoder> perf_defaults;
   if (nullable_defaults && nullable_defaults->has_perf_sample_defaults()) {
     perf_defaults.emplace(nullable_defaults->perf_sample_defaults());
   }
diff --git a/src/trace_processor/importers/proto/perf_sample_tracker_unittest.cc b/src/trace_processor/importers/proto/perf_sample_tracker_unittest.cc
index 61819a9..7515a04 100644
--- a/src/trace_processor/importers/proto/perf_sample_tracker_unittest.cc
+++ b/src/trace_processor/importers/proto/perf_sample_tracker_unittest.cc
@@ -213,10 +213,10 @@
 
   EXPECT_NE(stream.perf_session_id, stream2.perf_session_id);
 
-  base::Optional<int64_t> shard_count = context.storage->GetIndexedStats(
+  std::optional<int64_t> shard_count = context.storage->GetIndexedStats(
       stats::perf_process_shard_count,
       static_cast<int>(stream.perf_session_id));
-  base::Optional<int64_t> chosen_shard = context.storage->GetIndexedStats(
+  std::optional<int64_t> chosen_shard = context.storage->GetIndexedStats(
       stats::perf_chosen_process_shard,
       static_cast<int>(stream.perf_session_id));
 
@@ -225,10 +225,10 @@
   ASSERT_TRUE(chosen_shard.has_value());
   EXPECT_EQ(chosen_shard.value(), 7);
 
-  base::Optional<int64_t> shard_count2 = context.storage->GetIndexedStats(
+  std::optional<int64_t> shard_count2 = context.storage->GetIndexedStats(
       stats::perf_process_shard_count,
       static_cast<int>(stream.perf_session_id));
-  base::Optional<int64_t> chosen_shard2 = context.storage->GetIndexedStats(
+  std::optional<int64_t> chosen_shard2 = context.storage->GetIndexedStats(
       stats::perf_chosen_process_shard,
       static_cast<int>(stream.perf_session_id));
 
diff --git a/src/trace_processor/importers/proto/profile_module.cc b/src/trace_processor/importers/proto/profile_module.cc
index ec860da..c337869 100644
--- a/src/trace_processor/importers/proto/profile_module.cc
+++ b/src/trace_processor/importers/proto/profile_module.cc
@@ -251,7 +251,7 @@
       sequence_state->state()->sequence_stack_profile_tracker();
   ProfilePacketInternLookup intern_lookup(sequence_state);
   uint64_t callstack_iid = sample.callstack_iid();
-  base::Optional<CallsiteId> cs_id =
+  std::optional<CallsiteId> cs_id =
       stack_tracker.FindOrInsertCallstack(callstack_iid, &intern_lookup);
 
   // A failed lookup of the interned callstack can mean either:
@@ -285,7 +285,7 @@
   StringPool::Id cpu_mode_id =
       storage->InternString(ProfilePacketUtils::StringifyCpuMode(cpu_mode));
 
-  base::Optional<StringPool::Id> unwind_error_id;
+  std::optional<StringPool::Id> unwind_error_id;
   if (sample.has_unwind_error()) {
     auto unwind_error =
         static_cast<Profiling::StackUnwindError>(sample.unwind_error());
diff --git a/src/trace_processor/importers/proto/profile_packet_utils.h b/src/trace_processor/importers/proto/profile_packet_utils.h
index 683348c..64b2c50 100644
--- a/src/trace_processor/importers/proto/profile_packet_utils.h
+++ b/src/trace_processor/importers/proto/profile_packet_utils.h
@@ -16,8 +16,8 @@
 
 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_PROFILE_PACKET_UTILS_H_
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_PROFILE_PACKET_UTILS_H_
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 #include "src/trace_processor/importers/proto/packet_sequence_state.h"
 #include "src/trace_processor/importers/proto/stack_profile_tracker.h"
@@ -133,7 +133,7 @@
       : seq_state_(seq_state) {}
   ~ProfilePacketInternLookup() override;
 
-  base::Optional<base::StringView> GetString(
+  std::optional<base::StringView> GetString(
       SequenceStackProfileTracker::SourceStringId iid,
       SequenceStackProfileTracker::InternedStringType type) const override {
     protos::pbzero::InternedString::Decoder* decoder = nullptr;
@@ -155,37 +155,37 @@
         break;
     }
     if (!decoder)
-      return base::nullopt;
+      return std::nullopt;
     return base::StringView(reinterpret_cast<const char*>(decoder->str().data),
                             decoder->str().size);
   }
 
-  base::Optional<SequenceStackProfileTracker::SourceMapping> GetMapping(
+  std::optional<SequenceStackProfileTracker::SourceMapping> GetMapping(
       SequenceStackProfileTracker::SourceMappingId iid) const override {
     auto* decoder = seq_state_->LookupInternedMessage<
         protos::pbzero::InternedData::kMappingsFieldNumber,
         protos::pbzero::Mapping>(iid);
     if (!decoder)
-      return base::nullopt;
+      return std::nullopt;
     return ProfilePacketUtils::MakeSourceMapping(*decoder);
   }
 
-  base::Optional<SequenceStackProfileTracker::SourceFrame> GetFrame(
+  std::optional<SequenceStackProfileTracker::SourceFrame> GetFrame(
       SequenceStackProfileTracker::SourceFrameId iid) const override {
     auto* decoder = seq_state_->LookupInternedMessage<
         protos::pbzero::InternedData::kFramesFieldNumber,
         protos::pbzero::Frame>(iid);
     if (!decoder)
-      return base::nullopt;
+      return std::nullopt;
     return ProfilePacketUtils::MakeSourceFrame(*decoder);
   }
 
-  base::Optional<SequenceStackProfileTracker::SourceCallstack> GetCallstack(
+  std::optional<SequenceStackProfileTracker::SourceCallstack> GetCallstack(
       SequenceStackProfileTracker::SourceCallstackId iid) const override {
     auto* interned_message_view = seq_state_->GetInternedMessageView(
         protos::pbzero::InternedData::kCallstacksFieldNumber, iid);
     if (!interned_message_view)
-      return base::nullopt;
+      return std::nullopt;
     protos::pbzero::Callstack::Decoder decoder(
         interned_message_view->message().data(),
         interned_message_view->message().length());
diff --git a/src/trace_processor/importers/proto/profiler_util.cc b/src/trace_processor/importers/proto/profiler_util.cc
index 315eb45..79a5448 100644
--- a/src/trace_processor/importers/proto/profiler_util.cc
+++ b/src/trace_processor/importers/proto/profiler_util.cc
@@ -15,8 +15,8 @@
  */
 
 #include "src/trace_processor/importers/proto/profiler_util.h"
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "src/trace_processor/storage/trace_storage.h"
 
@@ -29,32 +29,32 @@
 // * /data/app/~~[randomStringA]/[packageName]-[randomStringB]/base.apk
 // The latter is newer (R+), and was added to avoid leaking package names via
 // mountinfo of incremental apk mounts.
-base::Optional<base::StringView> PackageFromApp(base::StringView location) {
+std::optional<base::StringView> PackageFromApp(base::StringView location) {
   location = location.substr(base::StringView("/data/app/").size());
   size_t start = 0;
   if (location.at(0) == '~') {
     size_t slash = location.find('/');
     if (slash == base::StringView::npos) {
-      return base::nullopt;
+      return std::nullopt;
     }
     start = slash + 1;
   }
   size_t end = location.find('/', start + 1);
   if (end == base::StringView::npos) {
-    return base::nullopt;
+    return std::nullopt;
   }
   location = location.substr(start, end);
   size_t minus = location.find('-');
   if (minus == base::StringView::npos) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return location.substr(0, minus);
 }
 
 }  // namespace
 
-base::Optional<std::string> PackageFromLocation(TraceStorage* storage,
-                                                base::StringView location) {
+std::optional<std::string> PackageFromLocation(TraceStorage* storage,
+                                               base::StringView location) {
   // List of some hardcoded apps that do not follow the scheme used in
   // PackageFromApp. Ask for yours to be added.
   //
@@ -146,12 +146,12 @@
   // Deal with paths to /data/app/...
 
   auto extract_package =
-      [storage](base::StringView path) -> base::Optional<std::string> {
+      [storage](base::StringView path) -> std::optional<std::string> {
     auto package = PackageFromApp(path);
     if (!package) {
       PERFETTO_DLOG("Failed to parse %s", path.ToStdString().c_str());
       storage->IncrementStats(stats::deobfuscate_location_parse_error);
-      return base::nullopt;
+      return std::nullopt;
     }
     return package->ToStdString();
   };
@@ -176,7 +176,7 @@
     return extract_package(data_app_path);
   }
 
-  return base::nullopt;
+  return std::nullopt;
 }
 
 std::string FullyQualifiedDeobfuscatedName(
diff --git a/src/trace_processor/importers/proto/profiler_util.h b/src/trace_processor/importers/proto/profiler_util.h
index 6e9ca99..cbf8ad1 100644
--- a/src/trace_processor/importers/proto/profiler_util.h
+++ b/src/trace_processor/importers/proto/profiler_util.h
@@ -17,9 +17,9 @@
 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_PROFILER_UTIL_H_
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_PROFILER_UTIL_H_
 
+#include <optional>
 #include <string>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 #include "src/trace_processor/storage/trace_storage.h"
 
@@ -32,8 +32,8 @@
     protos::pbzero::ObfuscatedClass::Decoder& cls,
     protos::pbzero::ObfuscatedMember::Decoder& member);
 
-base::Optional<std::string> PackageFromLocation(TraceStorage* storage,
-                                                base::StringView location);
+std::optional<std::string> PackageFromLocation(TraceStorage* storage,
+                                               base::StringView location);
 
 }  // namespace trace_processor
 }  // namespace perfetto
diff --git a/src/trace_processor/importers/proto/proto_importer_module.h b/src/trace_processor/importers/proto/proto_importer_module.h
index 3ff56aa..cc2c3a2 100644
--- a/src/trace_processor/importers/proto/proto_importer_module.h
+++ b/src/trace_processor/importers/proto/proto_importer_module.h
@@ -17,8 +17,9 @@
 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_PROTO_IMPORTER_MODULE_H_
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_PROTO_IMPORTER_MODULE_H_
 
+#include <optional>
+
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/importers/common/trace_parser.h"
 
 namespace perfetto {
@@ -54,8 +55,8 @@
   // Allow auto conversion from util::Status to Handled / Error result.
   ModuleResult(base::Status status)
       : ignored_(false),
-        error_(status.ok() ? base::nullopt
-                           : base::make_optional(status.message())) {}
+        error_(status.ok() ? std::nullopt
+                           : std::make_optional(status.message())) {}
 
   // Constructs a result that indicates the module ignored the packet and is
   // deferring the handling of the packet to other modules.
@@ -88,7 +89,7 @@
       : ignored_(false), error_(error) {}
 
   bool ignored_;
-  base::Optional<std::string> error_;
+  std::optional<std::string> error_;
 };
 
 // Base class for modules.
diff --git a/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc b/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc
index ff841aa..7ed4723 100644
--- a/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc
+++ b/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc
@@ -140,9 +140,9 @@
                     int32_t next_prio));
 
   MOCK_METHOD3(PushCounter,
-               base::Optional<CounterId>(int64_t timestamp,
-                                         double value,
-                                         TrackId track_id));
+               std::optional<CounterId>(int64_t timestamp,
+                                        double value,
+                                        TrackId track_id));
 };
 
 class MockProcessTracker : public ProcessTracker {
@@ -152,7 +152,7 @@
 
   MOCK_METHOD4(SetProcessMetadata,
                UniquePid(uint32_t pid,
-                         base::Optional<uint32_t> ppid,
+                         std::optional<uint32_t> ppid,
                          base::StringView process_name,
                          base::StringView cmdline));
 
@@ -195,29 +195,29 @@
       : SliceTracker(context) {}
 
   MOCK_METHOD5(Begin,
-               base::Optional<SliceId>(int64_t timestamp,
-                                       TrackId track_id,
-                                       StringId cat,
-                                       StringId name,
-                                       SetArgsCallback args_callback));
+               std::optional<SliceId>(int64_t timestamp,
+                                      TrackId track_id,
+                                      StringId cat,
+                                      StringId name,
+                                      SetArgsCallback args_callback));
   MOCK_METHOD5(End,
-               base::Optional<SliceId>(int64_t timestamp,
-                                       TrackId track_id,
-                                       StringId cat,
-                                       StringId name,
-                                       SetArgsCallback args_callback));
+               std::optional<SliceId>(int64_t timestamp,
+                                      TrackId track_id,
+                                      StringId cat,
+                                      StringId name,
+                                      SetArgsCallback args_callback));
   MOCK_METHOD6(Scoped,
-               base::Optional<SliceId>(int64_t timestamp,
-                                       TrackId track_id,
-                                       StringId cat,
-                                       StringId name,
-                                       int64_t duration,
-                                       SetArgsCallback args_callback));
+               std::optional<SliceId>(int64_t timestamp,
+                                      TrackId track_id,
+                                      StringId cat,
+                                      StringId name,
+                                      int64_t duration,
+                                      SetArgsCallback args_callback));
   MOCK_METHOD4(StartSlice,
-               base::Optional<SliceId>(int64_t timestamp,
-                                       TrackId track_id,
-                                       SetArgsCallback args_callback,
-                                       std::function<SliceId()> inserter));
+               std::optional<SliceId>(int64_t timestamp,
+                                      TrackId track_id,
+                                      SetArgsCallback args_callback,
+                                      std::function<SliceId()> inserter));
 };
 
 class ProtoTraceParserTest : public ::testing::Test {
diff --git a/src/trace_processor/importers/proto/proto_trace_reader.cc b/src/trace_processor/importers/proto/proto_trace_reader.cc
index f3b06fb..f947c0f 100644
--- a/src/trace_processor/importers/proto/proto_trace_reader.cc
+++ b/src/trace_processor/importers/proto/proto_trace_reader.cc
@@ -16,11 +16,11 @@
 
 #include "src/trace_processor/importers/proto/proto_trace_reader.h"
 
+#include <optional>
 #include <string>
 
 #include "perfetto/base/build_config.h"
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/ext/base/utils.h"
 #include "perfetto/protozero/proto_decoder.h"
@@ -365,7 +365,7 @@
   uint32_t snapshot_id = context_->clock_tracker->AddSnapshot(clock_timestamps);
 
   // Add the all the clock snapshots to the clock snapshot table.
-  base::Optional<int64_t> trace_ts_for_check;
+  std::optional<int64_t> trace_ts_for_check;
   for (const auto& clock_timestamp : clock_timestamps) {
     // If the clock is incremental, we need to use 0 to map correctly to
     // |absolute_timestamp|.
@@ -398,7 +398,7 @@
   return util::OkStatus();
 }
 
-base::Optional<StringId> ProtoTraceReader::GetBuiltinClockNameOrNull(
+std::optional<StringId> ProtoTraceReader::GetBuiltinClockNameOrNull(
     int64_t clock_id) {
   switch (clock_id) {
     case protos::pbzero::ClockSnapshot::Clock::REALTIME:
@@ -414,7 +414,7 @@
     case protos::pbzero::ClockSnapshot::Clock::BOOTTIME:
       return context_->storage->InternString("BOOTTIME");
     default:
-      return base::nullopt;
+      return std::nullopt;
   }
 }
 
diff --git a/src/trace_processor/importers/proto/proto_trace_reader.h b/src/trace_processor/importers/proto/proto_trace_reader.h
index 3776358..1c554a6 100644
--- a/src/trace_processor/importers/proto/proto_trace_reader.h
+++ b/src/trace_processor/importers/proto/proto_trace_reader.h
@@ -75,7 +75,7 @@
                          TraceBlobView interned_data);
   void ParseTraceConfig(ConstBytes);
 
-  base::Optional<StringId> GetBuiltinClockNameOrNull(int64_t clock_id);
+  std::optional<StringId> GetBuiltinClockNameOrNull(int64_t clock_id);
 
   PacketSequenceState* GetIncrementalStateForPacketSequence(
       uint32_t sequence_id) {
diff --git a/src/trace_processor/importers/proto/stack_profile_tracker.cc b/src/trace_processor/importers/proto/stack_profile_tracker.cc
index cfe90d2..fa1969b 100644
--- a/src/trace_processor/importers/proto/stack_profile_tracker.cc
+++ b/src/trace_processor/importers/proto/stack_profile_tracker.cc
@@ -46,7 +46,7 @@
   string_map_.emplace(id, str.ToStdString());
 }
 
-base::Optional<MappingId> SequenceStackProfileTracker::AddMapping(
+std::optional<MappingId> SequenceStackProfileTracker::AddMapping(
     SourceMappingId id,
     const SourceMapping& mapping,
     const InternLookup* intern_lookup) {
@@ -69,7 +69,7 @@
   if (!opt_build_id) {
     context_->storage->IncrementStats(stats::stackprofile_invalid_string_id);
     PERFETTO_DLOG("Invalid string.");
-    return base::nullopt;
+    return std::nullopt;
   }
   const StringId raw_build_id = opt_build_id.value();
   NullTermStringView raw_build_id_str =
@@ -101,7 +101,7 @@
 
   tables::StackProfileMappingTable* mappings =
       context_->storage->mutable_stack_profile_mapping_table();
-  base::Optional<MappingId> cur_id;
+  std::optional<MappingId> cur_id;
   auto it = mapping_idx_.find(row);
   if (it != mapping_idx_.end()) {
     cur_id = it->second;
@@ -136,16 +136,16 @@
   return cur_id;
 }
 
-base::Optional<FrameId> SequenceStackProfileTracker::AddFrame(
+std::optional<FrameId> SequenceStackProfileTracker::AddFrame(
     SourceFrameId id,
     const SourceFrame& frame,
     const InternLookup* intern_lookup) {
-  base::Optional<std::string> opt_name = FindOrInsertString(
+  std::optional<std::string> opt_name = FindOrInsertString(
       frame.name_id, intern_lookup, InternedStringType::kFunctionName);
   if (!opt_name) {
     context_->storage->IncrementStats(stats::stackprofile_invalid_string_id);
     PERFETTO_DLOG("Invalid string.");
-    return base::nullopt;
+    return std::nullopt;
   }
   const std::string& name = *opt_name;
   const StringId str_id =
@@ -154,7 +154,7 @@
   auto opt_mapping = FindOrInsertMapping(frame.mapping_id, intern_lookup);
   if (!opt_mapping) {
     context_->storage->IncrementStats(stats::stackprofile_invalid_mapping_id);
-    return base::nullopt;
+    return std::nullopt;
   }
   MappingId mapping_id = *opt_mapping;
   const auto& mappings = context_->storage->stack_profile_mapping_table();
@@ -167,7 +167,7 @@
 
   auto* frames = context_->storage->mutable_stack_profile_frame_table();
 
-  base::Optional<FrameId> cur_id;
+  std::optional<FrameId> cur_id;
   auto it = frame_idx_.find(row);
   if (it != frame_idx_.end()) {
     cur_id = it->second;
@@ -192,7 +192,7 @@
           mapping_id, static_cast<uint64_t>(row.rel_pc), *cur_id);
       if (base::Contains(name, '.')) {
         // Java frames always contain a '.'
-        base::Optional<std::string> package =
+        std::optional<std::string> package =
             PackageFromLocation(context_->storage.get(), mapping_name);
         if (package) {
           NameInPackage nip{str_id, context_->storage->InternString(
@@ -212,19 +212,19 @@
   return cur_id;
 }
 
-base::Optional<CallsiteId> SequenceStackProfileTracker::AddCallstack(
+std::optional<CallsiteId> SequenceStackProfileTracker::AddCallstack(
     SourceCallstackId id,
     const SourceCallstack& frame_ids,
     const InternLookup* intern_lookup) {
   if (frame_ids.empty())
-    return base::nullopt;
+    return std::nullopt;
 
-  base::Optional<CallsiteId> parent_id;
+  std::optional<CallsiteId> parent_id;
   for (uint32_t depth = 0; depth < frame_ids.size(); ++depth) {
     auto opt_frame_id = FindOrInsertFrame(frame_ids[depth], intern_lookup);
     if (!opt_frame_id) {
       context_->storage->IncrementStats(stats::stackprofile_invalid_frame_id);
-      return base::nullopt;
+      return std::nullopt;
     }
     FrameId frame_id = *opt_frame_id;
 
@@ -256,7 +256,7 @@
   return it->second;
 }
 
-base::Optional<StringId> SequenceStackProfileTracker::FindAndInternString(
+std::optional<StringId> SequenceStackProfileTracker::FindAndInternString(
     SourceStringId id,
     const InternLookup* intern_lookup,
     SequenceStackProfileTracker::InternedStringType type) {
@@ -270,7 +270,7 @@
   return context_->storage->InternString(base::StringView(*opt_str));
 }
 
-base::Optional<std::string> SequenceStackProfileTracker::FindOrInsertString(
+std::optional<std::string> SequenceStackProfileTracker::FindOrInsertString(
     SourceStringId id,
     const InternLookup* intern_lookup,
     SequenceStackProfileTracker::InternedStringType type) {
@@ -285,20 +285,20 @@
         context_->storage->IncrementStats(
             stats::stackprofile_invalid_string_id);
         PERFETTO_DLOG("Invalid string.");
-        return base::nullopt;
+        return std::nullopt;
       }
       return str->ToStdString();
     }
-    return base::nullopt;
+    return std::nullopt;
   }
 
   return it->second;
 }
 
-base::Optional<MappingId> SequenceStackProfileTracker::FindOrInsertMapping(
+std::optional<MappingId> SequenceStackProfileTracker::FindOrInsertMapping(
     SourceMappingId mapping_id,
     const InternLookup* intern_lookup) {
-  base::Optional<MappingId> res;
+  std::optional<MappingId> res;
   auto it = mapping_ids_.find(mapping_id);
   if (it == mapping_ids_.end()) {
     if (intern_lookup) {
@@ -315,10 +315,10 @@
   return res;
 }
 
-base::Optional<FrameId> SequenceStackProfileTracker::FindOrInsertFrame(
+std::optional<FrameId> SequenceStackProfileTracker::FindOrInsertFrame(
     SourceFrameId frame_id,
     const InternLookup* intern_lookup) {
-  base::Optional<FrameId> res;
+  std::optional<FrameId> res;
   auto it = frame_ids_.find(frame_id);
   if (it == frame_ids_.end()) {
     if (intern_lookup) {
@@ -337,10 +337,10 @@
   return res;
 }
 
-base::Optional<CallsiteId> SequenceStackProfileTracker::FindOrInsertCallstack(
+std::optional<CallsiteId> SequenceStackProfileTracker::FindOrInsertCallstack(
     SourceCallstackId callstack_id,
     const InternLookup* intern_lookup) {
-  base::Optional<CallsiteId> res;
+  std::optional<CallsiteId> res;
   auto it = callstack_ids_.find(callstack_id);
   if (it == callstack_ids_.end()) {
     auto interned_callstack = intern_lookup->GetCallstack(callstack_id);
diff --git a/src/trace_processor/importers/proto/stack_profile_tracker.h b/src/trace_processor/importers/proto/stack_profile_tracker.h
index c88f2f3..a29d3c1 100644
--- a/src/trace_processor/importers/proto/stack_profile_tracker.h
+++ b/src/trace_processor/importers/proto/stack_profile_tracker.h
@@ -18,9 +18,9 @@
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_STACK_PROFILE_TRACKER_H_
 
 #include <deque>
+#include <optional>
 #include <unordered_map>
 
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/storage/trace_storage.h"
 #include "src/trace_processor/tables/profiler_tables_py.h"
 
@@ -201,12 +201,12 @@
    public:
     virtual ~InternLookup();
 
-    virtual base::Optional<base::StringView> GetString(
+    virtual std::optional<base::StringView> GetString(
         SourceStringId,
         InternedStringType) const = 0;
-    virtual base::Optional<SourceMapping> GetMapping(SourceMappingId) const = 0;
-    virtual base::Optional<SourceFrame> GetFrame(SourceFrameId) const = 0;
-    virtual base::Optional<SourceCallstack> GetCallstack(
+    virtual std::optional<SourceMapping> GetMapping(SourceMappingId) const = 0;
+    virtual std::optional<SourceFrame> GetFrame(SourceFrameId) const = 0;
+    virtual std::optional<SourceCallstack> GetCallstack(
         SourceCallstackId) const = 0;
   };
 
@@ -214,14 +214,14 @@
   ~SequenceStackProfileTracker();
 
   void AddString(SourceStringId, base::StringView);
-  base::Optional<MappingId> AddMapping(
+  std::optional<MappingId> AddMapping(
       SourceMappingId,
       const SourceMapping&,
       const InternLookup* intern_lookup = nullptr);
-  base::Optional<FrameId> AddFrame(SourceFrameId,
-                                   const SourceFrame&,
-                                   const InternLookup* intern_lookup = nullptr);
-  base::Optional<CallsiteId> AddCallstack(
+  std::optional<FrameId> AddFrame(SourceFrameId,
+                                  const SourceFrame&,
+                                  const InternLookup* intern_lookup = nullptr);
+  std::optional<CallsiteId> AddCallstack(
       SourceCallstackId,
       const SourceCallstack&,
       const InternLookup* intern_lookup = nullptr);
@@ -238,21 +238,20 @@
   // This is to support both ProfilePackets that contain the interned data
   // (for Android Q) and where the interned data is kept globally in
   // InternedData (for versions newer than Q).
-  base::Optional<StringId> FindAndInternString(
+  std::optional<StringId> FindAndInternString(SourceStringId,
+                                              const InternLookup* intern_lookup,
+                                              InternedStringType type);
+  std::optional<std::string> FindOrInsertString(
       SourceStringId,
       const InternLookup* intern_lookup,
       InternedStringType type);
-  base::Optional<std::string> FindOrInsertString(
-      SourceStringId,
-      const InternLookup* intern_lookup,
-      InternedStringType type);
-  base::Optional<MappingId> FindOrInsertMapping(
+  std::optional<MappingId> FindOrInsertMapping(
       SourceMappingId,
       const InternLookup* intern_lookup);
-  base::Optional<FrameId> FindOrInsertFrame(SourceFrameId,
-                                            const InternLookup* intern_lookup);
+  std::optional<FrameId> FindOrInsertFrame(SourceFrameId,
+                                           const InternLookup* intern_lookup);
 
-  base::Optional<CallsiteId> FindOrInsertCallstack(
+  std::optional<CallsiteId> FindOrInsertCallstack(
       SourceCallstackId,
       const InternLookup* intern_lookup);
 
diff --git a/src/trace_processor/importers/proto/statsd_module.cc b/src/trace_processor/importers/proto/statsd_module.cc
index 555ccaa..472506c 100644
--- a/src/trace_processor/importers/proto/statsd_module.cc
+++ b/src/trace_processor/importers/proto/statsd_module.cc
@@ -146,7 +146,7 @@
                                      size_t size,
                                      const char* name) {
   pool_.AddFromFileDescriptorSet(data, size);
-  base::Optional<uint32_t> opt_idx = pool_.FindDescriptorIdx(name);
+  std::optional<uint32_t> opt_idx = pool_.FindDescriptorIdx(name);
   if (opt_idx.has_value()) {
     descriptor_ = &pool_.descriptors()[opt_idx.value()];
   }
@@ -195,7 +195,7 @@
 
   AsyncTrackSetTracker::TrackSetId track_set = InternAsyncTrackSetId();
   TrackId track = context_->async_track_set_tracker->Scoped(track_set, ts, 0);
-  base::Optional<SliceId> opt_slice =
+  std::optional<SliceId> opt_slice =
       context_->slice_tracker->Scoped(ts, track, kNullStringId, atom_name, 0);
   if (!opt_slice) {
     return;
diff --git a/src/trace_processor/importers/proto/statsd_module.h b/src/trace_processor/importers/proto/statsd_module.h
index e5157d2..999a339 100644
--- a/src/trace_processor/importers/proto/statsd_module.h
+++ b/src/trace_processor/importers/proto/statsd_module.h
@@ -18,9 +18,9 @@
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_STATSD_MODULE_H_
 
 #include <cstdint>
+#include <optional>
 
 #include "perfetto/ext/base/flat_hash_map.h"
-#include "perfetto/ext/base/optional.h"
 #include "protos/perfetto/trace/trace_packet.pbzero.h"
 #include "src/trace_processor/importers/common/async_track_set_tracker.h"
 #include "src/trace_processor/importers/common/trace_parser.h"
@@ -76,7 +76,7 @@
   base::FlatHashMap<uint32_t, StringId> atom_names_;
   PoolAndDescriptor pool_;
   util::ProtoToArgsParser args_parser_;
-  base::Optional<AsyncTrackSetTracker::TrackSetId> track_set_id_;
+  std::optional<AsyncTrackSetTracker::TrackSetId> track_set_id_;
 };
 
 }  // namespace trace_processor
diff --git a/src/trace_processor/importers/proto/system_probes_parser.cc b/src/trace_processor/importers/proto/system_probes_parser.cc
index 3a3c438..da175fa 100644
--- a/src/trace_processor/importers/proto/system_probes_parser.cc
+++ b/src/trace_processor/importers/proto/system_probes_parser.cc
@@ -48,7 +48,7 @@
 
 namespace {
 
-base::Optional<int> VersionStringToSdkVersion(const std::string& version) {
+std::optional<int> VersionStringToSdkVersion(const std::string& version) {
   // TODO(lalitm): remove this when the SDK version polling saturates
   // S/T traces in practice.
   if (base::StartsWith(version, "T") || base::StartsWith(version, "S")) {
@@ -82,21 +82,21 @@
   }
   // If we reached this point, we don't know how to parse this version
   // so just return null.
-  return base::nullopt;
+  return std::nullopt;
 }
 
-base::Optional<int> FingerprintToSdkVersion(const std::string& fingerprint) {
+std::optional<int> FingerprintToSdkVersion(const std::string& fingerprint) {
   // Try to parse the SDK version from the fingerprint.
   // Examples of fingerprints:
   // google/shamu/shamu:7.0/NBD92F/3753956:userdebug/dev-keys
   // google/coral/coral:12/SP1A.210812.015/7679548:userdebug/dev-keys
   size_t colon = fingerprint.find(':');
   if (colon == std::string::npos)
-    return base::nullopt;
+    return std::nullopt;
 
   size_t slash = fingerprint.find('/', colon);
   if (slash == std::string::npos)
-    return base::nullopt;
+    return std::nullopt;
 
   std::string version = fingerprint.substr(colon + 1, slash - (colon + 1));
   return VersionStringToSdkVersion(version);
@@ -600,7 +600,7 @@
 
   // If we have the SDK version in the trace directly just use that.
   // Otherwise, try and parse it from the fingerprint.
-  base::Optional<int64_t> opt_sdk_version;
+  std::optional<int64_t> opt_sdk_version;
   if (packet.has_android_sdk_version()) {
     opt_sdk_version = static_cast<int64_t>(packet.android_sdk_version());
   } else if (packet.has_android_build_fingerprint()) {
diff --git a/src/trace_processor/importers/proto/track_event_parser.cc b/src/trace_processor/importers/proto/track_event_parser.cc
index ab74bb1..2373f70 100644
--- a/src/trace_processor/importers/proto/track_event_parser.cc
+++ b/src/trace_processor/importers/proto/track_event_parser.cc
@@ -17,10 +17,10 @@
 #include "src/trace_processor/importers/proto/track_event_parser.h"
 
 #include <iostream>
+#include <optional>
 #include <string>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_writer.h"
 #include "perfetto/trace_processor/status.h"
 #include "src/trace_processor/importers/common/args_tracker.h"
@@ -175,7 +175,7 @@
   return result;
 }
 
-base::Optional<base::Status> MaybeParseUnsymbolizedSourceLocation(
+std::optional<base::Status> MaybeParseUnsymbolizedSourceLocation(
     std::string prefix,
     const protozero::Field& field,
     util::ProtoToArgsParser::Delegate& delegate) {
@@ -185,7 +185,7 @@
   if (!decoder) {
     // Lookup failed fall back on default behaviour which will just put
     // the iid into the args table.
-    return base::nullopt;
+    return std::nullopt;
   }
   // Interned mapping_id loses it's meaning when the sequence ends. So we need
   // to get an id from stack_profile_mapping table.
@@ -196,7 +196,7 @@
           ->sequence_stack_profile_tracker()
           .FindOrInsertMapping(decoder->mapping_id(), &intern_lookup);
   if (!mapping_id) {
-    return base::nullopt;
+    return std::nullopt;
   }
   delegate.AddUnsignedInteger(
       util::ProtoToArgsParser::Key(prefix + ".mapping_id"), mapping_id->value);
@@ -205,7 +205,7 @@
   return base::OkStatus();
 }
 
-base::Optional<base::Status> MaybeParseSourceLocation(
+std::optional<base::Status> MaybeParseSourceLocation(
     std::string prefix,
     const protozero::Field& field,
     util::ProtoToArgsParser::Delegate& delegate) {
@@ -214,7 +214,7 @@
   if (!decoder) {
     // Lookup failed fall back on default behaviour which will just put
     // the source_location_iid into the args table.
-    return base::nullopt;
+    return std::nullopt;
   }
 
   delegate.AddString(util::ProtoToArgsParser::Key(prefix + ".file_name"),
@@ -426,7 +426,7 @@
     //      TrackEvent types), or
     //   b) a default track.
     if (track_uuid_) {
-      base::Optional<TrackId> opt_track_id =
+      std::optional<TrackId> opt_track_id =
           track_event_tracker_->GetDescriptorTrack(track_uuid_, name_id_,
                                                    packet_sequence_id_);
       if (!opt_track_id) {
@@ -581,7 +581,7 @@
             track_id_ = context_->track_tracker
                             ->GetOrCreateLegacyChromeGlobalInstantTrack();
             legacy_passthrough_utid_ = utid_;
-            utid_ = base::nullopt;
+            utid_ = std::nullopt;
             break;
           case LegacyEvent::SCOPE_PROCESS:
             if (!upid_) {
@@ -593,7 +593,7 @@
                 context_->track_tracker->InternLegacyChromeProcessInstantTrack(
                     *upid_);
             legacy_passthrough_utid_ = utid_;
-            utid_ = base::nullopt;
+            utid_ = std::nullopt;
             break;
         }
         break;
@@ -697,9 +697,9 @@
     PERFETTO_DCHECK(track_uuid_it);
     PERFETTO_DCHECK(index < TrackEventData::kMaxNumExtraCounters);
 
-    base::Optional<TrackId> track_id = track_event_tracker_->GetDescriptorTrack(
+    std::optional<TrackId> track_id = track_event_tracker_->GetDescriptorTrack(
         *track_uuid_it, kNullStringId, packet_sequence_id_);
-    base::Optional<uint32_t> counter_row =
+    std::optional<uint32_t> counter_row =
         storage_->counter_track_table().id().IndexOf(*track_id);
 
     double value = event_data_->extra_counter_values[index];
@@ -757,12 +757,12 @@
     }
 
     tables::SliceTable::RowReference slice_ref = *opt_thread_slice_ref;
-    base::Optional<int64_t> tts = slice_ref.thread_ts();
+    std::optional<int64_t> tts = slice_ref.thread_ts();
     if (tts) {
       PERFETTO_DCHECK(thread_timestamp_);
       slice_ref.set_thread_dur(*thread_timestamp_ - *tts);
     }
-    base::Optional<int64_t> tic = slice_ref.thread_instruction_count();
+    std::optional<int64_t> tic = slice_ref.thread_instruction_count();
     if (tic) {
       PERFETTO_DCHECK(event_data_->thread_instruction_count);
       slice_ref.set_thread_instruction_delta(
@@ -800,7 +800,7 @@
     return util::OkStatus();
   }
 
-  base::Optional<uint64_t> GetLegacyEventId() {
+  std::optional<uint64_t> GetLegacyEventId() {
     if (legacy_event_.has_unscoped_id())
       return legacy_event_.unscoped_id();
     // TODO(andrewbb): Catapult doesn't support global_id and local_id on flow
@@ -808,7 +808,7 @@
     // to be some callsites supplying local_id in chromium), but we would have
     // to consider the process ID for local IDs and use a separate ID scope for
     // global_id and unscoped_id.
-    return base::nullopt;
+    return std::nullopt;
   }
 
   util::Status ParseFlowEventV1(char phase) {
@@ -902,7 +902,7 @@
     // up nested underneath their parent slices.
     int64_t duration_ns = 0;
     int64_t tidelta = 0;
-    base::Optional<tables::SliceTable::Id> opt_slice_id;
+    std::optional<tables::SliceTable::Id> opt_slice_id;
     auto args_inserter = [this, phase](BoundInserter* inserter) {
       ParseTrackEventArgs(inserter);
       // For legacy MARK event, add phase for JSON exporter.
@@ -1364,9 +1364,9 @@
     row.category = category_id_;
     row.name = name_id_;
     row.thread_ts = thread_timestamp_;
-    row.thread_dur = base::nullopt;
+    row.thread_dur = std::nullopt;
     row.thread_instruction_count = thread_instruction_count_;
-    row.thread_instruction_delta = base::nullopt;
+    row.thread_instruction_delta = std::nullopt;
     return row;
   }
 
@@ -1388,15 +1388,15 @@
   StringId name_id_;
   uint64_t track_uuid_;
   TrackId track_id_;
-  base::Optional<UniqueTid> utid_;
-  base::Optional<UniqueTid> upid_;
-  base::Optional<int64_t> thread_timestamp_;
-  base::Optional<int64_t> thread_instruction_count_;
+  std::optional<UniqueTid> utid_;
+  std::optional<UniqueTid> upid_;
+  std::optional<int64_t> thread_timestamp_;
+  std::optional<int64_t> thread_instruction_count_;
   // All events in legacy JSON require a thread ID, but for some types of
   // events (e.g. async events or process/global-scoped instants), we don't
   // store it in the slice/track model. To pass the utid through to the json
   // export, we store it in an arg.
-  base::Optional<UniqueTid> legacy_passthrough_utid_;
+  std::optional<UniqueTid> legacy_passthrough_utid_;
 
   uint32_t packet_sequence_id_;
 };
@@ -1550,7 +1550,7 @@
                                   util::ProtoToArgsParser::Delegate& delegate) {
         AddActiveProcess(delegate.packet_timestamp(), field.as_int32());
         // Fallthrough so that the parser adds pid as a regular arg.
-        return base::nullopt;
+        return std::nullopt;
       });
 
   for (uint16_t index : kReflectFields) {
diff --git a/src/trace_processor/importers/proto/track_event_tokenizer.cc b/src/trace_processor/importers/proto/track_event_tokenizer.cc
index 35c76a3..6b655f4 100644
--- a/src/trace_processor/importers/proto/track_event_tokenizer.cc
+++ b/src/trace_processor/importers/proto/track_event_tokenizer.cc
@@ -327,7 +327,7 @@
       return;
     }
 
-    base::Optional<double> value;
+    std::optional<double> value;
     if (event.has_counter_value()) {
       value = track_event_tracker_->ConvertToAbsoluteCounterValue(
           track_uuid, packet.trusted_packet_sequence_id(),
@@ -408,7 +408,7 @@
           "Ignoring TrackEvent with more extra_{double_,}counter_values than "
           "TrackEventData::kMaxNumExtraCounters");
     }
-    base::Optional<double> abs_value =
+    std::optional<double> abs_value =
         track_event_tracker_->ConvertToAbsoluteCounterValue(
             *track_uuid_it, trusted_packet_sequence_id,
             static_cast<double>(*value_it));
diff --git a/src/trace_processor/importers/proto/track_event_tracker.cc b/src/trace_processor/importers/proto/track_event_tracker.cc
index f460614..7591028 100644
--- a/src/trace_processor/importers/proto/track_event_tracker.cc
+++ b/src/trace_processor/importers/proto/track_event_tracker.cc
@@ -180,11 +180,11 @@
   return thread_tracks_[utid] = InsertThreadTrack(utid);
 }
 
-base::Optional<TrackId> TrackEventTracker::GetDescriptorTrack(
+std::optional<TrackId> TrackEventTracker::GetDescriptorTrack(
     uint64_t uuid,
     StringId event_name,
-    base::Optional<uint32_t> packet_sequence_id) {
-  base::Optional<TrackId> track_id =
+    std::optional<uint32_t> packet_sequence_id) {
+  std::optional<TrackId> track_id =
       GetDescriptorTrackImpl(uuid, packet_sequence_id);
   if (!track_id || event_name.is_null())
     return track_id;
@@ -208,19 +208,19 @@
   return track_id;
 }
 
-base::Optional<TrackId> TrackEventTracker::GetDescriptorTrackImpl(
+std::optional<TrackId> TrackEventTracker::GetDescriptorTrackImpl(
     uint64_t uuid,
-    base::Optional<uint32_t> packet_sequence_id) {
+    std::optional<uint32_t> packet_sequence_id) {
   auto it = descriptor_tracks_.find(uuid);
   if (it != descriptor_tracks_.end())
     return it->second;
 
-  base::Optional<ResolvedDescriptorTrack> resolved_track =
+  std::optional<ResolvedDescriptorTrack> resolved_track =
       ResolveDescriptorTrack(uuid, nullptr);
   if (!resolved_track)
-    return base::nullopt;
+    return std::nullopt;
 
-  // The reservation must exist as |resolved_track| would have been nullopt
+  // The reservation must exist as |resolved_track| would have been std::nullopt
   // otherwise.
   auto reserved_it = reserved_descriptor_tracks_.find(uuid);
   PERFETTO_CHECK(reserved_it != reserved_descriptor_tracks_.end());
@@ -229,7 +229,7 @@
 
   // We resolve parent_id here to ensure that it's going to be smaller
   // than the id of the child.
-  base::Optional<TrackId> parent_id;
+  std::optional<TrackId> parent_id;
   if (reservation.parent_uuid != 0) {
     parent_id = GetDescriptorTrackImpl(reservation.parent_uuid);
   }
@@ -321,7 +321,7 @@
   PERFETTO_FATAL("For GCC");
 }
 
-base::Optional<TrackEventTracker::ResolvedDescriptorTrack>
+std::optional<TrackEventTracker::ResolvedDescriptorTrack>
 TrackEventTracker::ResolveDescriptorTrack(
     uint64_t uuid,
     std::vector<uint64_t>* descendent_uuids) {
@@ -331,7 +331,7 @@
 
   auto reservation_it = reserved_descriptor_tracks_.find(uuid);
   if (reservation_it == reserved_descriptor_tracks_.end())
-    return base::nullopt;
+    return std::nullopt;
 
   // Resolve process and thread id for tracks produced from within a pid
   // namespace.
@@ -353,16 +353,16 @@
       reservation.pid = *opt_resolved_pid;
   }
 
-  base::Optional<ResolvedDescriptorTrack> resolved_track =
+  std::optional<ResolvedDescriptorTrack> resolved_track =
       ResolveDescriptorTrackImpl(uuid, reservation, descendent_uuids);
   if (!resolved_track) {
-    return base::nullopt;
+    return std::nullopt;
   }
   resolved_descriptor_tracks_[uuid] = *resolved_track;
   return resolved_track;
 }
 
-base::Optional<TrackEventTracker::ResolvedDescriptorTrack>
+std::optional<TrackEventTracker::ResolvedDescriptorTrack>
 TrackEventTracker::ResolveDescriptorTrackImpl(
     uint64_t uuid,
     const DescriptorTrackReservation& reservation,
@@ -370,7 +370,7 @@
   static constexpr size_t kMaxAncestors = 10;
 
   // Try to resolve any parent tracks recursively, too.
-  base::Optional<ResolvedDescriptorTrack> parent_resolved_track;
+  std::optional<ResolvedDescriptorTrack> parent_resolved_track;
   if (reservation.parent_uuid) {
     // Input data may contain loops or extremely long ancestor track chains. To
     // avoid stack overflow in these situations, we keep track of the ancestors
@@ -387,7 +387,7 @@
           "Too many ancestors in parent_track_uuid hierarchy at track %" PRIu64
           " with parent %" PRIu64,
           uuid, reservation.parent_uuid);
-      return base::nullopt;
+      return std::nullopt;
     }
 
     if (std::find(descendent_uuids->begin(), descendent_uuids->end(),
@@ -396,7 +396,7 @@
           "Loop detected in parent_track_uuid hierarchy at track %" PRIu64
           " with parent %" PRIu64,
           uuid, reservation.parent_uuid);
-      return base::nullopt;
+      return std::nullopt;
     }
 
     parent_resolved_track =
@@ -429,7 +429,7 @@
                     *reservation.pid, *reservation.tid, old_uuid, uuid,
                     reservation.min_timestamp);
 
-      utid = context_->process_tracker->StartNewThread(base::nullopt,
+      utid = context_->process_tracker->StartNewThread(std::nullopt,
                                                        *reservation.tid);
 
       // Associate the new thread with its process.
@@ -462,7 +462,7 @@
                     reservation.min_timestamp);
 
       upid = context_->process_tracker->StartNewProcess(
-          base::nullopt, base::nullopt, *reservation.pid, kNullStringId,
+          std::nullopt, std::nullopt, *reservation.pid, kNullStringId,
           ThreadNamePriority::kTrackDescriptor);
 
       descriptor_uuids_by_upid_[upid] = uuid;
@@ -505,7 +505,7 @@
           "Loop detected in parent_track_uuid hierarchy at track %" PRIu64
           " with parent %" PRIu64,
           uuid, kDefaultDescriptorTrackUuid);
-      return base::nullopt;
+      return std::nullopt;
     }
 
     // This track will be implicitly a child of the default global track.
@@ -518,7 +518,7 @@
 TrackId TrackEventTracker::GetOrCreateDefaultDescriptorTrack() {
   // If the default track was already reserved (e.g. because a producer emitted
   // a descriptor for it) or created, resolve and return it.
-  base::Optional<TrackId> track_id =
+  std::optional<TrackId> track_id =
       GetDescriptorTrack(kDefaultDescriptorTrackUuid);
   if (track_id)
     return *track_id;
@@ -529,7 +529,7 @@
   return *GetDescriptorTrack(kDefaultDescriptorTrackUuid);
 }
 
-base::Optional<double> TrackEventTracker::ConvertToAbsoluteCounterValue(
+std::optional<double> TrackEventTracker::ConvertToAbsoluteCounterValue(
     uint64_t counter_track_uuid,
     uint32_t packet_sequence_id,
     double value) {
@@ -537,14 +537,14 @@
   if (reservation_it == reserved_descriptor_tracks_.end()) {
     PERFETTO_DLOG("Unknown counter track with uuid %" PRIu64,
                   counter_track_uuid);
-    return base::nullopt;
+    return std::nullopt;
   }
 
   DescriptorTrackReservation& reservation = reservation_it->second;
   if (!reservation.is_counter) {
     PERFETTO_DLOG("Track with uuid %" PRIu64 " is not a counter track",
                   counter_track_uuid);
-    return base::nullopt;
+    return std::nullopt;
   }
 
   if (reservation.unit_multiplier > 0)
@@ -558,7 +558,7 @@
           " got:%" PRIu32 ")",
           counter_track_uuid, reservation.packet_sequence_id,
           packet_sequence_id);
-      return base::nullopt;
+      return std::nullopt;
     }
 
     reservation.latest_value += value;
diff --git a/src/trace_processor/importers/proto/track_event_tracker.h b/src/trace_processor/importers/proto/track_event_tracker.h
index 58db962..2eb7092 100644
--- a/src/trace_processor/importers/proto/track_event_tracker.h
+++ b/src/trace_processor/importers/proto/track_event_tracker.h
@@ -102,21 +102,21 @@
   // each |uuid| resolves and inserts the track (and its parent tracks,
   // following the parent_uuid chain recursively) based on reservations made for
   // the |uuid|. If the track is a child track and doesn't have a name yet,
-  // updates the track's name to event_name. Returns nullopt if no track for a
-  // descriptor with this |uuid| has been reserved.
+  // updates the track's name to event_name. Returns std::nullopt if no track
+  // for a descriptor with this |uuid| has been reserved.
   // TODO(lalitm): this method needs to be split up and moved back to
   // TrackTracker.
-  base::Optional<TrackId> GetDescriptorTrack(
+  std::optional<TrackId> GetDescriptorTrack(
       uint64_t uuid,
       StringId event_name = kNullStringId,
-      base::Optional<uint32_t> packet_sequence_id = base::nullopt);
+      std::optional<uint32_t> packet_sequence_id = std::nullopt);
 
   // Converts the given counter value to an absolute value in the unit of the
   // counter, applying incremental delta encoding or unit multipliers as
   // necessary. If the counter uses incremental encoding, |packet_sequence_id|
-  // must match the one in its track reservation. Returns base::nullopt if the
+  // must match the one in its track reservation. Returns std::nullopt if the
   // counter track is unknown or an invalid |packet_sequence_id| was passed.
-  base::Optional<double> ConvertToAbsoluteCounterValue(
+  std::optional<double> ConvertToAbsoluteCounterValue(
       uint64_t counter_track_uuid,
       uint32_t packet_sequence_id,
       double value);
@@ -144,15 +144,15 @@
     range_of_interest_start_us_ = range_of_interest_start_us;
   }
 
-  base::Optional<int64_t> range_of_interest_start_us() const {
+  std::optional<int64_t> range_of_interest_start_us() const {
     return range_of_interest_start_us_;
   }
 
  private:
   struct DescriptorTrackReservation {
     uint64_t parent_uuid = 0;
-    base::Optional<uint32_t> pid;
-    base::Optional<uint32_t> tid;
+    std::optional<uint32_t> pid;
+    std::optional<uint32_t> tid;
     int64_t min_timestamp = 0;  // only set if |pid| and/or |tid| is set.
     StringId name = kNullStringId;
     bool use_separate_track = false;
@@ -220,14 +220,14 @@
     UniquePid upid_;
   };
 
-  base::Optional<TrackId> GetDescriptorTrackImpl(
+  std::optional<TrackId> GetDescriptorTrackImpl(
       uint64_t uuid,
-      base::Optional<uint32_t> packet_sequence_id = base::nullopt);
+      std::optional<uint32_t> packet_sequence_id = std::nullopt);
   TrackId CreateTrackFromResolved(const ResolvedDescriptorTrack&);
-  base::Optional<ResolvedDescriptorTrack> ResolveDescriptorTrack(
+  std::optional<ResolvedDescriptorTrack> ResolveDescriptorTrack(
       uint64_t uuid,
       std::vector<uint64_t>* descendent_uuids);
-  base::Optional<ResolvedDescriptorTrack> ResolveDescriptorTrackImpl(
+  std::optional<ResolvedDescriptorTrack> ResolveDescriptorTrackImpl(
       uint64_t uuid,
       const DescriptorTrackReservation&,
       std::vector<uint64_t>* descendent_uuids);
@@ -261,7 +261,7 @@
 
   const StringId default_descriptor_track_name_ = kNullStringId;
 
-  base::Optional<int64_t> range_of_interest_start_us_;
+  std::optional<int64_t> range_of_interest_start_us_;
 
   TraceProcessorContext* const context_;
 };
diff --git a/src/trace_processor/importers/proto/translation_table_module.h b/src/trace_processor/importers/proto/translation_table_module.h
index a180335..a318e60 100644
--- a/src/trace_processor/importers/proto/translation_table_module.h
+++ b/src/trace_processor/importers/proto/translation_table_module.h
@@ -18,8 +18,8 @@
 #define SRC_TRACE_PROCESSOR_IMPORTERS_PROTO_TRANSLATION_TABLE_MODULE_H_
 
 #include <cstdint>
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "protos/perfetto/trace/trace_packet.pbzero.h"
 #include "src/trace_processor/importers/proto/proto_importer_module.h"
 #include "src/trace_processor/types/trace_processor_context.h"
diff --git a/src/trace_processor/importers/syscalls/syscall_tracker_unittest.cc b/src/trace_processor/importers/syscalls/syscall_tracker_unittest.cc
index 67ef441..cc0117d 100644
--- a/src/trace_processor/importers/syscalls/syscall_tracker_unittest.cc
+++ b/src/trace_processor/importers/syscalls/syscall_tracker_unittest.cc
@@ -34,17 +34,17 @@
   virtual ~MockSliceTracker() = default;
 
   MOCK_METHOD5(Begin,
-               base::Optional<SliceId>(int64_t timestamp,
-                                       TrackId track_id,
-                                       StringId cat,
-                                       StringId name,
-                                       SetArgsCallback args_callback));
+               std::optional<SliceId>(int64_t timestamp,
+                                      TrackId track_id,
+                                      StringId cat,
+                                      StringId name,
+                                      SetArgsCallback args_callback));
   MOCK_METHOD5(End,
-               base::Optional<SliceId>(int64_t timestamp,
-                                       TrackId track_id,
-                                       StringId cat,
-                                       StringId name,
-                                       SetArgsCallback args_callback));
+               std::optional<SliceId>(int64_t timestamp,
+                                      TrackId track_id,
+                                      StringId cat,
+                                      StringId name,
+                                      SetArgsCallback args_callback));
 };
 
 class SyscallTrackerTest : public ::testing::Test {
@@ -68,9 +68,9 @@
   StringId begin_name = kNullStringId;
   StringId end_name = kNullStringId;
   EXPECT_CALL(*slice_tracker, Begin(100, track, kNullStringId, _, _))
-      .WillOnce(DoAll(SaveArg<3>(&begin_name), Return(base::nullopt)));
+      .WillOnce(DoAll(SaveArg<3>(&begin_name), Return(std::nullopt)));
   EXPECT_CALL(*slice_tracker, End(110, track, kNullStringId, _, _))
-      .WillOnce(DoAll(SaveArg<3>(&end_name), Return(base::nullopt)));
+      .WillOnce(DoAll(SaveArg<3>(&end_name), Return(std::nullopt)));
 
   SyscallTracker* syscall_tracker = SyscallTracker::GetOrCreate(&context);
   syscall_tracker->Enter(100 /*ts*/, 42 /*utid*/, 57 /*sys_read*/);
@@ -84,9 +84,9 @@
   StringId begin_name = kNullStringId;
   StringId end_name = kNullStringId;
   EXPECT_CALL(*slice_tracker, Begin(100, track, kNullStringId, _, _))
-      .WillOnce(DoAll(SaveArg<3>(&begin_name), Return(base::nullopt)));
+      .WillOnce(DoAll(SaveArg<3>(&begin_name), Return(std::nullopt)));
   EXPECT_CALL(*slice_tracker, End(110, track, kNullStringId, _, _))
-      .WillOnce(DoAll(SaveArg<3>(&end_name), Return(base::nullopt)));
+      .WillOnce(DoAll(SaveArg<3>(&end_name), Return(std::nullopt)));
 
   SyscallTracker* syscall_tracker = SyscallTracker::GetOrCreate(&context);
   syscall_tracker->SetArchitecture(kAarch64);
@@ -101,9 +101,9 @@
   StringId begin_name = kNullStringId;
   StringId end_name = kNullStringId;
   EXPECT_CALL(*slice_tracker, Begin(100, track, kNullStringId, _, _))
-      .WillOnce(DoAll(SaveArg<3>(&begin_name), Return(base::nullopt)));
+      .WillOnce(DoAll(SaveArg<3>(&begin_name), Return(std::nullopt)));
   EXPECT_CALL(*slice_tracker, End(110, track, kNullStringId, _, _))
-      .WillOnce(DoAll(SaveArg<3>(&end_name), Return(base::nullopt)));
+      .WillOnce(DoAll(SaveArg<3>(&end_name), Return(std::nullopt)));
 
   SyscallTracker* syscall_tracker = SyscallTracker::GetOrCreate(&context);
   syscall_tracker->SetArchitecture(kX86_64);
diff --git a/src/trace_processor/importers/systrace/systrace_line_parser.cc b/src/trace_processor/importers/systrace/systrace_line_parser.cc
index 150124c..958cb7e 100644
--- a/src/trace_processor/importers/systrace/systrace_line_parser.cc
+++ b/src/trace_processor/importers/systrace/systrace_line_parser.cc
@@ -64,7 +64,7 @@
       ThreadNamePriority::kFtrace);
 
   if (!line.tgid_str.empty() && line.tgid_str != "-----") {
-    base::Optional<uint32_t> tgid = base::StringToUInt32(line.tgid_str);
+    std::optional<uint32_t> tgid = base::StringToUInt32(line.tgid_str);
     if (tgid) {
       context_->process_tracker->UpdateThread(line.pid, tgid.value());
     }
@@ -116,7 +116,7 @@
         line.ts, line.pid, line.args_str.c_str());
   } else if (line.event_name == "sched_waking") {
     auto comm = args["comm"];
-    base::Optional<uint32_t> wakee_pid = base::StringToUInt32(args["pid"]);
+    std::optional<uint32_t> wakee_pid = base::StringToUInt32(args["pid"]);
     if (!wakee_pid.has_value()) {
       return util::Status("Could not convert wakee_pid");
     }
@@ -129,8 +129,8 @@
         line.ts, wakee_utid, utid);
 
   } else if (line.event_name == "cpu_frequency") {
-    base::Optional<uint32_t> event_cpu = base::StringToUInt32(args["cpu_id"]);
-    base::Optional<double> new_state = base::StringToDouble(args["state"]);
+    std::optional<uint32_t> event_cpu = base::StringToUInt32(args["cpu_id"]);
+    std::optional<double> new_state = base::StringToDouble(args["state"]);
     if (!event_cpu.has_value()) {
       return util::Status("Could not convert event cpu");
     }
@@ -142,8 +142,8 @@
         cpufreq_name_id_, event_cpu.value());
     context_->event_tracker->PushCounter(line.ts, new_state.value(), track);
   } else if (line.event_name == "cpu_idle") {
-    base::Optional<uint32_t> event_cpu = base::StringToUInt32(args["cpu_id"]);
-    base::Optional<double> new_state = base::StringToDouble(args["state"]);
+    std::optional<uint32_t> event_cpu = base::StringToUInt32(args["cpu_id"]);
+    std::optional<double> new_state = base::StringToDouble(args["state"]);
     if (!event_cpu.has_value()) {
       return util::Status("Could not convert event cpu");
     }
@@ -261,7 +261,7 @@
       return util::Status("sched_blocked_reason: could not parse io_wait");
     }
     ThreadStateTracker::GetOrCreate(context_)->PushBlockedReason(
-        wakee_utid, static_cast<bool>(*io_wait), base::nullopt);
+        wakee_utid, static_cast<bool>(*io_wait), std::nullopt);
   } else if (line.event_name == "rss_stat") {
     // Format: rss_stat: size=8437760 member=1 curr=1 mm_id=2824390453
     auto size = base::StringToInt64(args["size"]);
@@ -274,9 +274,9 @@
     if (!member.has_value()) {
       return util::Status("rss_stat: could not parse member");
     }
-    base::Optional<bool> curr;
+    std::optional<bool> curr;
     if (!opt_curr.has_value()) {
-      curr = base::make_optional(static_cast<bool>(*opt_curr));
+      curr = std::make_optional(static_cast<bool>(*opt_curr));
     }
     rss_stat_tracker_.ParseRssStat(line.ts, line.pid, *size, *member, curr,
                                    mm_id);
diff --git a/src/trace_processor/importers/systrace/systrace_line_tokenizer.cc b/src/trace_processor/importers/systrace/systrace_line_tokenizer.cc
index e7fa5e8..054bc3e 100644
--- a/src/trace_processor/importers/systrace/systrace_line_tokenizer.cc
+++ b/src/trace_processor/importers/systrace/systrace_line_tokenizer.cc
@@ -78,19 +78,19 @@
   line->event_name = matches[5].str();
   line->args_str = SubstrTrim(matches.suffix());
 
-  base::Optional<uint32_t> maybe_pid = base::StringToUInt32(pid_str);
+  std::optional<uint32_t> maybe_pid = base::StringToUInt32(pid_str);
   if (!maybe_pid.has_value()) {
     return util::Status("Could not convert pid " + pid_str);
   }
   line->pid = maybe_pid.value();
 
-  base::Optional<uint32_t> maybe_cpu = base::StringToUInt32(cpu_str);
+  std::optional<uint32_t> maybe_cpu = base::StringToUInt32(cpu_str);
   if (!maybe_cpu.has_value()) {
     return util::Status("Could not convert cpu " + cpu_str);
   }
   line->cpu = maybe_cpu.value();
 
-  base::Optional<double> maybe_ts = base::StringToDouble(ts_str);
+  std::optional<double> maybe_ts = base::StringToDouble(ts_str);
   if (!maybe_ts.has_value()) {
     return util::Status("Could not convert ts");
   }
diff --git a/src/trace_processor/importers/systrace/systrace_parser.cc b/src/trace_processor/importers/systrace/systrace_parser.cc
index 538278d..ac16506 100644
--- a/src/trace_processor/importers/systrace/systrace_parser.cc
+++ b/src/trace_processor/importers/systrace/systrace_parser.cc
@@ -16,7 +16,8 @@
 
 #include "src/trace_processor/importers/systrace/systrace_parser.h"
 
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "perfetto/ext/base/string_utils.h"
 #include "src/trace_processor/importers/common/async_track_set_tracker.h"
 #include "src/trace_processor/importers/common/event_tracker.h"
diff --git a/src/trace_processor/importers/systrace/systrace_trace_parser.cc b/src/trace_processor/importers/systrace/systrace_trace_parser.cc
index 167b3c3..d908d17 100644
--- a/src/trace_processor/importers/systrace/systrace_trace_parser.cc
+++ b/src/trace_processor/importers/systrace/systrace_trace_parser.cc
@@ -143,9 +143,9 @@
                    tokens.size() >= 10) {
           // Format is:
           // user pid ppid vsz rss wchan pc s name my cmd line
-          const base::Optional<uint32_t> pid =
+          const std::optional<uint32_t> pid =
               base::StringToUInt32(tokens[1].ToStdString());
-          const base::Optional<uint32_t> ppid =
+          const std::optional<uint32_t> ppid =
               base::StringToUInt32(tokens[2].ToStdString());
           base::StringView name = tokens[8];
           // Command line may contain spaces, merge all remaining tokens:
@@ -163,9 +163,9 @@
                    tokens.size() >= 4) {
           // Format is:
           // username pid tid my cmd line
-          const base::Optional<uint32_t> tgid =
+          const std::optional<uint32_t> tgid =
               base::StringToUInt32(tokens[1].ToStdString());
-          const base::Optional<uint32_t> tid =
+          const std::optional<uint32_t> tid =
               base::StringToUInt32(tokens[2].ToStdString());
           // Command line may contain spaces, merge all remaining tokens:
           const char* cmd_start = tokens[3].data();
diff --git a/src/trace_processor/iterator_impl.h b/src/trace_processor/iterator_impl.h
index 272d13e..0c8b372 100644
--- a/src/trace_processor/iterator_impl.h
+++ b/src/trace_processor/iterator_impl.h
@@ -20,11 +20,11 @@
 #include <sqlite3.h>
 
 #include <memory>
+#include <optional>
 #include <vector>
 
 #include "perfetto/base/build_config.h"
 #include "perfetto/base/export.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/trace_processor/basic_types.h"
 #include "perfetto/trace_processor/iterator.h"
 #include "perfetto/trace_processor/status.h"
@@ -87,7 +87,7 @@
     int ret = sqlite3_step(*stmt_);
     if (PERFETTO_UNLIKELY(ret != SQLITE_ROW && ret != SQLITE_DONE)) {
       status_ = base::ErrStatus("%s", sqlite_utils::FormatErrorMessage(
-                                          stmt_.get(), base::nullopt, db_, ret)
+                                          stmt_.get(), std::nullopt, db_, ret)
                                           .c_message());
       stmt_.reset();
       return false;
diff --git a/src/trace_processor/metrics/metrics.cc b/src/trace_processor/metrics/metrics.cc
index c713532..34c7863 100644
--- a/src/trace_processor/metrics/metrics.cc
+++ b/src/trace_processor/metrics/metrics.cc
@@ -631,9 +631,9 @@
     if (sqlite3_value_type(argv[i]) != SQLITE_TEXT)
       return base::ErrStatus("RUN_METRIC: all keys must be strings");
 
-    base::Optional<std::string> key_str = sqlite_utils::SqlValueToString(
+    std::optional<std::string> key_str = sqlite_utils::SqlValueToString(
         sqlite_utils::SqliteValueToSqlValue(argv[i]));
-    base::Optional<std::string> value_str = sqlite_utils::SqlValueToString(
+    std::optional<std::string> value_str = sqlite_utils::SqlValueToString(
         sqlite_utils::SqliteValueToSqlValue(argv[i + 1]));
 
     if (!value_str) {
diff --git a/src/trace_processor/metrics/metrics.h b/src/trace_processor/metrics/metrics.h
index 72a10f2..16e004c 100644
--- a/src/trace_processor/metrics/metrics.h
+++ b/src/trace_processor/metrics/metrics.h
@@ -46,12 +46,12 @@
   // Optional because not all protos need to have a field associated with them
   // in the root proto; most files will be just be run using RUN_METRIC by
   // other files.
-  base::Optional<std::string> proto_field_name;
+  std::optional<std::string> proto_field_name;
 
   // The table name which will be created by the SQL below to read the proto
   // bytes from.
   // Should only be set when |proto_field_name| is set.
-  base::Optional<std::string> output_table_name;
+  std::optional<std::string> output_table_name;
 
   // The SQL run by this metric.
   std::string sql;
diff --git a/src/trace_processor/metrics/metrics_unittest.cc b/src/trace_processor/metrics/metrics_unittest.cc
index 29f8f6d..6ba25e2 100644
--- a/src/trace_processor/metrics/metrics_unittest.cc
+++ b/src/trace_processor/metrics/metrics_unittest.cc
@@ -77,7 +77,7 @@
   DescriptorPool pool;
   ProtoDescriptor descriptor("file.proto", ".perfetto.protos",
                              ".perfetto.protos.TestProto",
-                             ProtoDescriptor::Type::kMessage, base::nullopt);
+                             ProtoDescriptor::Type::kMessage, std::nullopt);
   descriptor.AddField(FieldDescriptor(
       "int_value", 1, FieldDescriptorProto::TYPE_INT64, "", false));
 
@@ -100,7 +100,7 @@
   DescriptorPool pool;
   ProtoDescriptor descriptor("file.proto", ".perfetto.protos",
                              ".perfetto.protos.TestProto",
-                             ProtoDescriptor::Type::kMessage, base::nullopt);
+                             ProtoDescriptor::Type::kMessage, std::nullopt);
   descriptor.AddField(FieldDescriptor(
       "double_value", 1, FieldDescriptorProto::TYPE_DOUBLE, "", false));
 
@@ -123,7 +123,7 @@
   DescriptorPool pool;
   ProtoDescriptor descriptor("file.proto", ".perfetto.protos",
                              ".perfetto.protos.TestProto",
-                             ProtoDescriptor::Type::kMessage, base::nullopt);
+                             ProtoDescriptor::Type::kMessage, std::nullopt);
   descriptor.AddField(FieldDescriptor(
       "string_value", 1, FieldDescriptorProto::TYPE_STRING, "", false));
 
@@ -149,13 +149,13 @@
   DescriptorPool pool;
   ProtoDescriptor nested("file.proto", ".perfetto.protos",
                          ".perfetto.protos.TestProto.NestedProto",
-                         ProtoDescriptor::Type::kMessage, base::nullopt);
+                         ProtoDescriptor::Type::kMessage, std::nullopt);
   nested.AddField(FieldDescriptor("nested_int_value", 1,
                                   FieldDescriptorProto::TYPE_INT64, "", false));
 
   ProtoDescriptor descriptor("file.proto", ".perfetto.protos",
                              ".perfetto.protos.TestProto",
-                             ProtoDescriptor::Type::kMessage, base::nullopt);
+                             ProtoDescriptor::Type::kMessage, std::nullopt);
   auto field =
       FieldDescriptor("nested_value", 1, FieldDescriptorProto::TYPE_MESSAGE,
                       ".perfetto.protos.TestProto.NestedProto", false);
@@ -197,7 +197,7 @@
   DescriptorPool pool;
   ProtoDescriptor descriptor("file.proto", ".perfetto.protos",
                              ".perfetto.protos.TestProto",
-                             ProtoDescriptor::Type::kMessage, base::nullopt);
+                             ProtoDescriptor::Type::kMessage, std::nullopt);
   descriptor.AddField(FieldDescriptor(
       "rep_int_value", 1, FieldDescriptorProto::TYPE_INT64, "", true));
 
@@ -235,7 +235,7 @@
   DescriptorPool pool;
   ProtoDescriptor enum_descriptor("file.proto", ".perfetto.protos",
                                   ".perfetto.protos.TestEnum",
-                                  ProtoDescriptor::Type::kEnum, base::nullopt);
+                                  ProtoDescriptor::Type::kEnum, std::nullopt);
   enum_descriptor.AddEnumValue(1, "FIRST");
   enum_descriptor.AddEnumValue(2, "SECOND");
   enum_descriptor.AddEnumValue(3, "THIRD");
@@ -243,7 +243,7 @@
 
   ProtoDescriptor descriptor("file.proto", ".perfetto.protos",
                              ".perfetto.protos.TestMessage",
-                             ProtoDescriptor::Type::kMessage, base::nullopt);
+                             ProtoDescriptor::Type::kMessage, std::nullopt);
   FieldDescriptor enum_field("enum_value", 1, FieldDescriptorProto::TYPE_ENUM,
                              ".perfetto.protos.TestEnum", false);
   enum_field.set_resolved_type_name(".perfetto.protos.TestEnum");
diff --git a/src/trace_processor/prelude/functions/create_function_internal.h b/src/trace_processor/prelude/functions/create_function_internal.h
index 83c0723..1f77459 100644
--- a/src/trace_processor/prelude/functions/create_function_internal.h
+++ b/src/trace_processor/prelude/functions/create_function_internal.h
@@ -18,10 +18,10 @@
 #define SRC_TRACE_PROCESSOR_PRELUDE_FUNCTIONS_CREATE_FUNCTION_INTERNAL_H_
 
 #include <sqlite3.h>
+#include <optional>
 #include <string>
 
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/trace_processor/basic_types.h"
 #include "src/trace_processor/util/sql_argument.h"
diff --git a/src/trace_processor/prelude/functions/create_view_function.cc b/src/trace_processor/prelude/functions/create_view_function.cc
index e93e8c7..3989de4 100644
--- a/src/trace_processor/prelude/functions/create_view_function.cc
+++ b/src/trace_processor/prelude/functions/create_view_function.cc
@@ -381,7 +381,7 @@
     table_->SetErrorMessage(sqlite3_mprintf(
         "%s: SQLite error while stepping statement: %s",
         table_->prototype_.function_name.c_str(),
-        sqlite_utils::FormatErrorMessage(stmt_, base::nullopt, table_->db_, ret)
+        sqlite_utils::FormatErrorMessage(stmt_, std::nullopt, table_->db_, ret)
             .c_message()));
     return ret;
   }
diff --git a/src/trace_processor/prelude/functions/stack_functions.cc b/src/trace_processor/prelude/functions/stack_functions.cc
index 0774d1d..2f8730b 100644
--- a/src/trace_processor/prelude/functions/stack_functions.cc
+++ b/src/trace_processor/prelude/functions/stack_functions.cc
@@ -21,12 +21,12 @@
 #include <cstring>
 #include <deque>
 #include <iterator>
+#include <optional>
 #include <type_traits>
 #include <vector>
 
 #include "perfetto/base/logging.h"
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/protozero/scattered_heap_buffer.h"
 #include "perfetto/trace_processor/basic_types.h"
 #include "perfetto/trace_processor/status.h"
diff --git a/src/trace_processor/prelude/functions/utils.h b/src/trace_processor/prelude/functions/utils.h
index b92de3c..c4c5392 100644
--- a/src/trace_processor/prelude/functions/utils.h
+++ b/src/trace_processor/prelude/functions/utils.h
@@ -255,7 +255,7 @@
   uint32_t arg_set_id = static_cast<uint32_t>(sqlite3_value_int(argv[0]));
   const char* key = reinterpret_cast<const char*>(sqlite3_value_text(argv[1]));
 
-  base::Optional<Variadic> opt_value;
+  std::optional<Variadic> opt_value;
   RETURN_IF_ERROR(storage->ExtractArg(arg_set_id, key, &opt_value));
 
   if (!opt_value)
diff --git a/src/trace_processor/prelude/operators/span_join_operator.cc b/src/trace_processor/prelude/operators/span_join_operator.cc
index 61aa3b6..7d4ccb8 100644
--- a/src/trace_processor/prelude/operators/span_join_operator.cc
+++ b/src/trace_processor/prelude/operators/span_join_operator.cc
@@ -43,7 +43,7 @@
   return name == kTsColumnName || name == kDurColumnName;
 }
 
-base::Optional<std::string> HasDuplicateColumns(
+std::optional<std::string> HasDuplicateColumns(
     const std::vector<SqliteTable::Column>& cols) {
   std::set<std::string> names;
   for (const auto& col : cols) {
@@ -51,7 +51,7 @@
       return col.name();
     names.insert(col.name());
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 std::string OpToString(int op) {
diff --git a/src/trace_processor/prelude/table_functions/ancestor.cc b/src/trace_processor/prelude/table_functions/ancestor.cc
index 4399397..c1656d9 100644
--- a/src/trace_processor/prelude/table_functions/ancestor.cc
+++ b/src/trace_processor/prelude/table_functions/ancestor.cc
@@ -209,13 +209,13 @@
 }
 
 // static
-base::Optional<std::vector<tables::SliceTable::RowNumber>>
+std::optional<std::vector<tables::SliceTable::RowNumber>>
 Ancestor::GetAncestorSlices(const tables::SliceTable& slices,
                             SliceId slice_id) {
   std::vector<tables::SliceTable::RowNumber> ret;
   auto status = GetAncestors(slices, slice_id, ret);
   if (!status.ok())
-    return base::nullopt;
+    return std::nullopt;
   return std::move(ret);  // -Wreturn-std-move-in-c++11
 }
 
diff --git a/src/trace_processor/prelude/table_functions/ancestor.h b/src/trace_processor/prelude/table_functions/ancestor.h
index eff2c7d..c625f16 100644
--- a/src/trace_processor/prelude/table_functions/ancestor.h
+++ b/src/trace_processor/prelude/table_functions/ancestor.h
@@ -16,8 +16,8 @@
 
 #ifndef SRC_TRACE_PROCESSOR_PRELUDE_TABLE_FUNCTIONS_ANCESTOR_H_
 #define SRC_TRACE_PROCESSOR_PRELUDE_TABLE_FUNCTIONS_ANCESTOR_H_
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/prelude/table_functions/table_function.h"
 #include "src/trace_processor/storage/trace_storage.h"
 #include "src/trace_processor/tables/profiler_tables.h"
@@ -75,9 +75,9 @@
                             std::unique_ptr<Table>& table_return) override;
 
   // Returns a vector of rows numbers which are ancestors of |slice_id|.
-  // Returns base::nullopt if an invalid |slice_id| is given. This is used by
+  // Returns std::nullopt if an invalid |slice_id| is given. This is used by
   // ConnectedFlow to traverse flow indirectly connected flow events.
-  static base::Optional<std::vector<tables::SliceTable::RowNumber>>
+  static std::optional<std::vector<tables::SliceTable::RowNumber>>
   GetAncestorSlices(const tables::SliceTable& slices, SliceId slice_id);
 
  private:
diff --git a/src/trace_processor/prelude/table_functions/descendant.cc b/src/trace_processor/prelude/table_functions/descendant.cc
index 89cd4a2..75cb8c9 100644
--- a/src/trace_processor/prelude/table_functions/descendant.cc
+++ b/src/trace_processor/prelude/table_functions/descendant.cc
@@ -193,13 +193,13 @@
 }
 
 // static
-base::Optional<std::vector<tables::SliceTable::RowNumber>>
+std::optional<std::vector<tables::SliceTable::RowNumber>>
 Descendant::GetDescendantSlices(const tables::SliceTable& slices,
                                 SliceId slice_id) {
   std::vector<tables::SliceTable::RowNumber> ret;
   auto status = GetDescendants(slices, slice_id, ret);
   if (!status.ok())
-    return base::nullopt;
+    return std::nullopt;
   return std::move(ret);
 }
 
diff --git a/src/trace_processor/prelude/table_functions/descendant.h b/src/trace_processor/prelude/table_functions/descendant.h
index d423d07..8e93811 100644
--- a/src/trace_processor/prelude/table_functions/descendant.h
+++ b/src/trace_processor/prelude/table_functions/descendant.h
@@ -17,7 +17,8 @@
 #ifndef SRC_TRACE_PROCESSOR_PRELUDE_TABLE_FUNCTIONS_DESCENDANT_H_
 #define SRC_TRACE_PROCESSOR_PRELUDE_TABLE_FUNCTIONS_DESCENDANT_H_
 
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "src/trace_processor/prelude/table_functions/table_function.h"
 #include "src/trace_processor/storage/trace_storage.h"
 
@@ -64,9 +65,9 @@
                             std::unique_ptr<Table>& table_return) override;
 
   // Returns a vector of slice rows which are descendants of |slice_id|. Returns
-  // base::nullopt if an invalid |slice_id| is given. This is used by
+  // std::nullopt if an invalid |slice_id| is given. This is used by
   // ConnectedFlow to traverse flow indirectly connected flow events.
-  static base::Optional<std::vector<tables::SliceTable::RowNumber>>
+  static std::optional<std::vector<tables::SliceTable::RowNumber>>
   GetDescendantSlices(const tables::SliceTable& slices, SliceId slice_id);
 
  private:
diff --git a/src/trace_processor/prelude/table_functions/experimental_annotated_stack.cc b/src/trace_processor/prelude/table_functions/experimental_annotated_stack.cc
index 494931b..8198376 100644
--- a/src/trace_processor/prelude/table_functions/experimental_annotated_stack.cc
+++ b/src/trace_processor/prelude/table_functions/experimental_annotated_stack.cc
@@ -16,7 +16,8 @@
 
 #include "src/trace_processor/prelude/table_functions/experimental_annotated_stack.h"
 
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "perfetto/ext/base/string_utils.h"
 #include "src/trace_processor/sqlite/sqlite_utils.h"
 #include "src/trace_processor/storage/trace_storage.h"
@@ -173,7 +174,7 @@
   // entries, each pointing at a frame.
   std::vector<CallsiteTable::RowNumber> cs_rows;
   cs_rows.push_back(opt_start_ref->ToRowNumber());
-  base::Optional<CallsiteId> maybe_parent_id = opt_start_ref->parent_id();
+  std::optional<CallsiteId> maybe_parent_id = opt_start_ref->parent_id();
   while (maybe_parent_id) {
     auto parent_ref = *cs_table.FindById(*maybe_parent_id);
     cs_rows.push_back(parent_ref.ToRowNumber());
diff --git a/src/trace_processor/prelude/table_functions/experimental_flamegraph.cc b/src/trace_processor/prelude/table_functions/experimental_flamegraph.cc
index f3fe53b..ae855be 100644
--- a/src/trace_processor/prelude/table_functions/experimental_flamegraph.cc
+++ b/src/trace_processor/prelude/table_functions/experimental_flamegraph.cc
@@ -119,8 +119,8 @@
     }
   }
 
-  base::Optional<UniquePid> upid;
-  base::Optional<std::string> upid_group;
+  std::optional<UniquePid> upid;
+  std::optional<std::string> upid_group;
   if (upid_it != cs.end()) {
     upid = static_cast<UniquePid>(upid_it->value.AsLong());
   } else {
diff --git a/src/trace_processor/prelude/table_functions/experimental_flamegraph.h b/src/trace_processor/prelude/table_functions/experimental_flamegraph.h
index 8a7e9ae..60792f9 100644
--- a/src/trace_processor/prelude/table_functions/experimental_flamegraph.h
+++ b/src/trace_processor/prelude/table_functions/experimental_flamegraph.h
@@ -34,8 +34,8 @@
     ProfileType profile_type;
     int64_t ts;
     std::vector<TimeConstraints> time_constraints;
-    base::Optional<UniquePid> upid;
-    base::Optional<std::string> upid_group;
+    std::optional<UniquePid> upid;
+    std::optional<std::string> upid_group;
     std::string focus_str;
   };
 
diff --git a/src/trace_processor/prelude/table_functions/experimental_flat_slice.cc b/src/trace_processor/prelude/table_functions/experimental_flat_slice.cc
index 9b38f80..c9bdfed 100644
--- a/src/trace_processor/prelude/table_functions/experimental_flat_slice.cc
+++ b/src/trace_processor/prelude/table_functions/experimental_flat_slice.cc
@@ -98,7 +98,7 @@
     row.category = kNullStringId;
     row.name = kNullStringId;
     row.arg_set_id = kInvalidArgSetId;
-    row.source_id = base::nullopt;
+    row.source_id = std::nullopt;
     row.start_bound = start_bound;
     row.end_bound = end_bound;
     return out->Insert(row).row;
@@ -111,7 +111,7 @@
   };
 
   struct ActiveSlice {
-    base::Optional<uint32_t> source_row;
+    std::optional<uint32_t> source_row;
     uint32_t out_row = std::numeric_limits<uint32_t>::max();
 
     bool is_sentinel() const { return !source_row; }
@@ -185,7 +185,7 @@
       return;
 
     // Otherwise, Add a sentinel slice after the end of the active slice.
-    t.active.source_row = base::nullopt;
+    t.active.source_row = std::nullopt;
     t.active.out_row = insert_sentinel(ts + dur, track_id);
   };
 
diff --git a/src/trace_processor/prelude/table_functions/experimental_flat_slice.h b/src/trace_processor/prelude/table_functions/experimental_flat_slice.h
index aa354c6..0cb10b5 100644
--- a/src/trace_processor/prelude/table_functions/experimental_flat_slice.h
+++ b/src/trace_processor/prelude/table_functions/experimental_flat_slice.h
@@ -17,7 +17,8 @@
 #ifndef SRC_TRACE_PROCESSOR_PRELUDE_TABLE_FUNCTIONS_EXPERIMENTAL_FLAT_SLICE_H_
 #define SRC_TRACE_PROCESSOR_PRELUDE_TABLE_FUNCTIONS_EXPERIMENTAL_FLAT_SLICE_H_
 
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "src/trace_processor/prelude/table_functions/table_function.h"
 #include "src/trace_processor/storage/trace_storage.h"
 
diff --git a/src/trace_processor/prelude/table_functions/experimental_sched_upid.cc b/src/trace_processor/prelude/table_functions/experimental_sched_upid.cc
index 54443bb..45a76ea 100644
--- a/src/trace_processor/prelude/table_functions/experimental_sched_upid.cc
+++ b/src/trace_processor/prelude/table_functions/experimental_sched_upid.cc
@@ -22,7 +22,7 @@
 #define PERFETTO_TP_SCHED_UPID_TABLE_DEF(NAME, PARENT, C)     \
   NAME(ExperimentalSchedUpidTable, "experimental_sched_upid") \
   PARENT(PERFETTO_TP_SCHED_SLICE_TABLE_DEF, C)                \
-  C(base::Optional<UniquePid>, upid)
+  C(std::optional<UniquePid>, upid)
 
 PERFETTO_TP_TABLE(PERFETTO_TP_SCHED_UPID_TABLE_DEF);
 
@@ -65,9 +65,9 @@
   return base::OkStatus();
 }
 
-ColumnStorage<base::Optional<UniquePid>>
+ColumnStorage<std::optional<UniquePid>>
 ExperimentalSchedUpid::ComputeUpidColumn() {
-  ColumnStorage<base::Optional<UniquePid>> upid;
+  ColumnStorage<std::optional<UniquePid>> upid;
   for (uint32_t i = 0; i < sched_slice_table_->row_count(); ++i) {
     upid.Append(thread_table_->upid()[sched_slice_table_->utid()[i]]);
   }
diff --git a/src/trace_processor/prelude/table_functions/experimental_sched_upid.h b/src/trace_processor/prelude/table_functions/experimental_sched_upid.h
index 7a9f23d..6837c18 100644
--- a/src/trace_processor/prelude/table_functions/experimental_sched_upid.h
+++ b/src/trace_processor/prelude/table_functions/experimental_sched_upid.h
@@ -41,7 +41,7 @@
                             std::unique_ptr<Table>& table_return) override;
 
  private:
-  ColumnStorage<base::Optional<UniquePid>> ComputeUpidColumn();
+  ColumnStorage<std::optional<UniquePid>> ComputeUpidColumn();
 
   const tables::SchedSliceTable* sched_slice_table_;
   const tables::ThreadTable* thread_table_;
diff --git a/src/trace_processor/prelude/table_functions/experimental_slice_layout.cc b/src/trace_processor/prelude/table_functions/experimental_slice_layout.cc
index 32bf906..e544dbb 100644
--- a/src/trace_processor/prelude/table_functions/experimental_slice_layout.cc
+++ b/src/trace_processor/prelude/table_functions/experimental_slice_layout.cc
@@ -16,7 +16,8 @@
 
 #include "src/trace_processor/prelude/table_functions/experimental_slice_layout.h"
 
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "src/trace_processor/sqlite/sqlite_utils.h"
@@ -88,7 +89,7 @@
     if (is_filter_track_ids && is_equal && is_string) {
       filter_string = c.value.AsString();
       for (base::StringSplitter sp(filter_string, ','); sp.Next();) {
-        base::Optional<uint32_t> maybe = base::CStringToUInt32(sp.cur_token());
+        std::optional<uint32_t> maybe = base::CStringToUInt32(sp.cur_token());
         if (maybe) {
           selected_tracks.insert(TrackId{maybe.value()});
         }
@@ -129,7 +130,7 @@
 tables::SliceTable::Id ExperimentalSliceLayout::InsertSlice(
     std::map<tables::SliceTable::Id, tables::SliceTable::Id>& id_map,
     tables::SliceTable::Id id,
-    base::Optional<tables::SliceTable::Id> parent_id) {
+    std::optional<tables::SliceTable::Id> parent_id) {
   if (parent_id) {
     tables::SliceTable::Id root_id = id_map[parent_id.value()];
     id_map[id] = root_id;
diff --git a/src/trace_processor/prelude/table_functions/experimental_slice_layout.h b/src/trace_processor/prelude/table_functions/experimental_slice_layout.h
index 5089e7a..19af803 100644
--- a/src/trace_processor/prelude/table_functions/experimental_slice_layout.h
+++ b/src/trace_processor/prelude/table_functions/experimental_slice_layout.h
@@ -59,7 +59,7 @@
   tables::SliceTable::Id InsertSlice(
       std::map<tables::SliceTable::Id, tables::SliceTable::Id>& id_map,
       tables::SliceTable::Id id,
-      base::Optional<tables::SliceTable::Id> parent_id);
+      std::optional<tables::SliceTable::Id> parent_id);
 
   // TODO(lalitm): remove this cache and move to having explicitly scoped
   // lifetimes of dynamic tables.
diff --git a/src/trace_processor/prelude/table_functions/experimental_slice_layout_unittest.cc b/src/trace_processor/prelude/table_functions/experimental_slice_layout_unittest.cc
index fe2a210..43c986d 100644
--- a/src/trace_processor/prelude/table_functions/experimental_slice_layout_unittest.cc
+++ b/src/trace_processor/prelude/table_functions/experimental_slice_layout_unittest.cc
@@ -72,18 +72,17 @@
       << "Actual:" << actual << "\nExpected:" << expected;
 }
 
-tables::SliceTable::Id Insert(
-    tables::SliceTable* table,
-    int64_t ts,
-    int64_t dur,
-    uint32_t track_id,
-    StringId name,
-    base::Optional<tables::SliceTable::Id> parent_id) {
+tables::SliceTable::Id Insert(tables::SliceTable* table,
+                              int64_t ts,
+                              int64_t dur,
+                              uint32_t track_id,
+                              StringId name,
+                              std::optional<tables::SliceTable::Id> parent_id) {
   tables::SliceTable::Row row;
   row.ts = ts;
   row.dur = dur;
   row.depth = 0;
-  base::Optional<tables::SliceTable::Id> id = parent_id;
+  std::optional<tables::SliceTable::Id> id = parent_id;
   while (id) {
     row.depth++;
     id = table->parent_id()[id.value().value];
@@ -100,7 +99,7 @@
   StringId name = pool.InternString("SingleRow");
 
   Insert(&slice_table, 1 /*ts*/, 5 /*dur*/, 1 /*track_id*/, name,
-         base::nullopt /*parent*/);
+         std::nullopt /*parent*/);
 
   ExperimentalSliceLayout gen(&pool, &slice_table);
 
@@ -120,7 +119,7 @@
   StringId name = pool.InternString("SingleRow");
 
   auto id = Insert(&slice_table, 1 /*ts*/, 5 /*dur*/, 1 /*track_id*/, name,
-                   base::nullopt);
+                   std::nullopt);
   Insert(&slice_table, 1 /*ts*/, 5 /*dur*/, 1 /*track_id*/, name, id);
 
   ExperimentalSliceLayout gen(&pool, &slice_table);
@@ -142,7 +141,7 @@
   StringId name = pool.InternString("MultipleRows");
 
   auto a = Insert(&slice_table, 1 /*ts*/, 5 /*dur*/, 1 /*track_id*/, name,
-                  base::nullopt);
+                  std::nullopt);
   auto b = Insert(&slice_table, 1 /*ts*/, 4 /*dur*/, 1 /*track_id*/, name, a);
   auto c = Insert(&slice_table, 1 /*ts*/, 3 /*dur*/, 1 /*track_id*/, name, b);
   auto d = Insert(&slice_table, 1 /*ts*/, 2 /*dur*/, 1 /*track_id*/, name, c);
@@ -174,10 +173,10 @@
   StringId name4 = pool.InternString("Track4");
 
   auto a = Insert(&slice_table, 1 /*ts*/, 4 /*dur*/, 1 /*track_id*/, name1,
-                  base::nullopt);
+                  std::nullopt);
   auto b = Insert(&slice_table, 1 /*ts*/, 2 /*dur*/, 1 /*track_id*/, name2, a);
   auto x = Insert(&slice_table, 4 /*ts*/, 4 /*dur*/, 2 /*track_id*/, name3,
-                  base::nullopt);
+                  std::nullopt);
   auto y = Insert(&slice_table, 4 /*ts*/, 2 /*dur*/, 2 /*track_id*/, name4, x);
   base::ignore_result(b);
   base::ignore_result(y);
@@ -208,13 +207,13 @@
   StringId name6 = pool.InternString("Slice6");
 
   auto a = Insert(&slice_table, 0 /*ts*/, 4 /*dur*/, 1 /*track_id*/, name1,
-                  base::nullopt);
+                  std::nullopt);
   auto b = Insert(&slice_table, 0 /*ts*/, 2 /*dur*/, 1 /*track_id*/, name2, a);
   auto p = Insert(&slice_table, 3 /*ts*/, 4 /*dur*/, 2 /*track_id*/, name3,
-                  base::nullopt);
+                  std::nullopt);
   auto q = Insert(&slice_table, 3 /*ts*/, 2 /*dur*/, 2 /*track_id*/, name4, p);
   auto x = Insert(&slice_table, 5 /*ts*/, 4 /*dur*/, 1 /*track_id*/, name5,
-                  base::nullopt);
+                  std::nullopt);
   auto y = Insert(&slice_table, 5 /*ts*/, 2 /*dur*/, 1 /*track_id*/, name6, x);
   base::ignore_result(b);
   base::ignore_result(q);
@@ -246,20 +245,20 @@
 
   // Group 1 exists just to create push group 2 down one row.
   auto a = Insert(&slice_table, 0 /*ts*/, 1 /*dur*/, 1 /*track_id*/, name,
-                  base::nullopt);
+                  std::nullopt);
   base::ignore_result(a);
 
   // Group 2 has a depth of 2 so it theoretically "nests" inside a group of
   // depth 4.
   auto c = Insert(&slice_table, 0 /*ts*/, 10 /*dur*/, 2 /*track_id*/, name,
-                  base::nullopt);
+                  std::nullopt);
   auto d = Insert(&slice_table, 0 /*ts*/, 9 /*dur*/, 2 /*track_id*/, name, c);
   base::ignore_result(d);
 
   // Group 3 has a depth of 4 so it could cause group 2 to "nest" if our
   // layout algorithm did not work correctly.
   auto p = Insert(&slice_table, 3 /*ts*/, 4 /*dur*/, 3 /*track_id*/, name,
-                  base::nullopt);
+                  std::nullopt);
   auto q = Insert(&slice_table, 3 /*ts*/, 3 /*dur*/, 3 /*track_id*/, name, p);
   auto r = Insert(&slice_table, 3 /*ts*/, 2 /*dur*/, 3 /*track_id*/, name, q);
   auto s = Insert(&slice_table, 3 /*ts*/, 1 /*dur*/, 3 /*track_id*/, name, r);
@@ -293,14 +292,14 @@
   StringId name5 = pool.InternString("Slice5");
 
   auto a = Insert(&slice_table, 0 /*ts*/, 4 /*dur*/, 1 /*track_id*/, name1,
-                  base::nullopt);
+                  std::nullopt);
   auto b = Insert(&slice_table, 0 /*ts*/, 2 /*dur*/, 1 /*track_id*/, name2, a);
   auto p = Insert(&slice_table, 3 /*ts*/, 4 /*dur*/, 2 /*track_id*/, name3,
-                  base::nullopt);
+                  std::nullopt);
   auto q = Insert(&slice_table, 3 /*ts*/, 2 /*dur*/, 2 /*track_id*/, name4, p);
   // This slice should be ignored as it's not in the filter below:
   Insert(&slice_table, 0 /*ts*/, 9 /*dur*/, 3 /*track_id*/, name5,
-         base::nullopt);
+         std::nullopt);
   base::ignore_result(b);
   base::ignore_result(q);
 
diff --git a/src/trace_processor/prelude/table_functions/flamegraph_construction_algorithms.cc b/src/trace_processor/prelude/table_functions/flamegraph_construction_algorithms.cc
index cd49b14..7424134 100644
--- a/src/trace_processor/prelude/table_functions/flamegraph_construction_algorithms.cc
+++ b/src/trace_processor/prelude/table_functions/flamegraph_construction_algorithms.cc
@@ -29,9 +29,9 @@
 struct MergedCallsite {
   StringId frame_name;
   StringId mapping_name;
-  base::Optional<StringId> source_file;
-  base::Optional<uint32_t> line_number;
-  base::Optional<uint32_t> parent_idx;
+  std::optional<StringId> source_file;
+  std::optional<uint32_t> line_number;
+  std::optional<uint32_t> parent_idx;
   bool operator<(const MergedCallsite& o) const {
     return std::tie(frame_name, mapping_name, parent_idx) <
            std::tie(o.frame_name, o.mapping_name, o.parent_idx);
@@ -60,15 +60,14 @@
       *mapping_tbl.id().IndexOf(frames_tbl.mapping()[frame_idx]);
   StringId mapping_name = mapping_tbl.name()[mapping_idx];
 
-  base::Optional<uint32_t> symbol_set_id =
-      frames_tbl.symbol_set_id()[frame_idx];
+  std::optional<uint32_t> symbol_set_id = frames_tbl.symbol_set_id()[frame_idx];
 
   if (!symbol_set_id) {
     StringId frame_name = frames_tbl.name()[frame_idx];
-    base::Optional<StringId> deobfuscated_name =
+    std::optional<StringId> deobfuscated_name =
         frames_tbl.deobfuscated_name()[frame_idx];
     return {{deobfuscated_name ? *deobfuscated_name : frame_name, mapping_name,
-             base::nullopt, base::nullopt, base::nullopt}};
+             std::nullopt, std::nullopt, std::nullopt}};
   }
 
   std::vector<MergedCallsite> result;
@@ -82,7 +81,7 @@
        ++i) {
     result.emplace_back(MergedCallsite{
         symbols_tbl.name()[i], mapping_name, symbols_tbl.source_file()[i],
-        symbols_tbl.line_number()[i], base::nullopt});
+        symbols_tbl.line_number()[i], std::nullopt});
   }
   std::reverse(result.begin(), result.end());
   return result;
@@ -91,8 +90,8 @@
 
 static FlamegraphTableAndMergedCallsites BuildFlamegraphTableTreeStructure(
     TraceStorage* storage,
-    base::Optional<UniquePid> upid,
-    base::Optional<std::string> upid_group,
+    std::optional<UniquePid> upid,
+    std::optional<std::string> upid_group,
     int64_t default_timestamp,
     StringId profile_type) {
   const tables::StackProfileCallsiteTable& callsites_tbl =
@@ -110,7 +109,7 @@
   // Aggregate callstacks by frame name / mapping name. Use symbolization
   // data.
   for (uint32_t i = 0; i < callsites_tbl.row_count(); ++i) {
-    base::Optional<uint32_t> parent_idx;
+    std::optional<uint32_t> parent_idx;
 
     auto opt_parent_id = callsites_tbl.parent_id()[i];
     if (opt_parent_id) {
@@ -136,7 +135,7 @@
           row.parent_id = tbl->id()[*parent_idx];
         } else {
           row.depth = 0;
-          row.parent_id = base::nullopt;
+          row.parent_id = std::nullopt;
         }
 
         // The 'ts' column is given a default value, taken from the query.
@@ -170,10 +169,10 @@
         MergedCallsite saved_callsite = it->first;
         callsites_to_rowid.erase(saved_callsite);
         if (saved_callsite.source_file != merged_callsite.source_file) {
-          saved_callsite.source_file = base::nullopt;
+          saved_callsite.source_file = std::nullopt;
         }
         if (saved_callsite.line_number != merged_callsite.line_number) {
-          saved_callsite.line_number = base::nullopt;
+          saved_callsite.line_number = std::nullopt;
         }
         callsites_to_rowid[saved_callsite] = it->second;
       }
@@ -335,7 +334,7 @@
   }
   StringId profile_type = storage->InternString("native");
   FlamegraphTableAndMergedCallsites table_and_callsites =
-      BuildFlamegraphTableTreeStructure(storage, upid, base::nullopt, timestamp,
+      BuildFlamegraphTableTreeStructure(storage, upid, std::nullopt, timestamp,
                                         profile_type);
   return BuildFlamegraphTableHeapSizeAndCount(
       std::move(table_and_callsites.tbl),
@@ -345,8 +344,8 @@
 std::unique_ptr<tables::ExperimentalFlamegraphNodesTable>
 BuildNativeCallStackSamplingFlamegraph(
     TraceStorage* storage,
-    base::Optional<UniquePid> upid,
-    base::Optional<std::string> upid_group,
+    std::optional<UniquePid> upid,
+    std::optional<std::string> upid_group,
     const std::vector<TimeConstraints>& time_constraints) {
   // 1.Extract required upids from input.
   std::unordered_set<UniquePid> upids;
@@ -354,7 +353,7 @@
     upids.insert(*upid);
   } else {
     for (base::StringSplitter sp(*upid_group, ','); sp.Next();) {
-      base::Optional<uint32_t> maybe = base::CStringToUInt32(sp.cur_token());
+      std::optional<uint32_t> maybe = base::CStringToUInt32(sp.cur_token());
       if (maybe) {
         upids.insert(*maybe);
       }
@@ -365,7 +364,7 @@
   std::set<tables::ThreadTable::Id> utids;
   RowMap threads_in_pid_rm;
   for (uint32_t i = 0; i < storage->thread_table().row_count(); ++i) {
-    base::Optional<uint32_t> row_upid = storage->thread_table().upid()[i];
+    std::optional<uint32_t> row_upid = storage->thread_table().upid()[i];
     if (row_upid && upids.count(*row_upid) > 0) {
       threads_in_pid_rm.Insert(i);
     }
diff --git a/src/trace_processor/prelude/table_functions/flamegraph_construction_algorithms.h b/src/trace_processor/prelude/table_functions/flamegraph_construction_algorithms.h
index fdda131..82c79b8 100644
--- a/src/trace_processor/prelude/table_functions/flamegraph_construction_algorithms.h
+++ b/src/trace_processor/prelude/table_functions/flamegraph_construction_algorithms.h
@@ -36,8 +36,8 @@
 std::unique_ptr<tables::ExperimentalFlamegraphNodesTable>
 BuildNativeCallStackSamplingFlamegraph(
     TraceStorage* storage,
-    base::Optional<UniquePid> upid,
-    base::Optional<std::string> upid_group,
+    std::optional<UniquePid> upid,
+    std::optional<std::string> upid_group,
     const std::vector<TimeConstraints>& time_constraints);
 }  // namespace trace_processor
 }  // namespace perfetto
diff --git a/src/trace_processor/rpc/httpd.cc b/src/trace_processor/rpc/httpd.cc
index 97bee91..2e59675 100644
--- a/src/trace_processor/rpc/httpd.cc
+++ b/src/trace_processor/rpc/httpd.cc
@@ -258,7 +258,7 @@
 void RunHttpRPCServer(std::unique_ptr<TraceProcessor> preloaded_instance,
                       std::string port_number) {
   Httpd srv(std::move(preloaded_instance));
-  base::Optional<int> port_opt = base::StringToInt32(port_number);
+  std::optional<int> port_opt = base::StringToInt32(port_number);
   int port = port_opt.has_value() ? *port_opt : kBindPort;
   srv.Run(port);
 }
diff --git a/src/trace_processor/sorter/trace_token_buffer.cc b/src/trace_processor/sorter/trace_token_buffer.cc
index c8d2899..7541a4d 100644
--- a/src/trace_processor/sorter/trace_token_buffer.cc
+++ b/src/trace_processor/sorter/trace_token_buffer.cc
@@ -22,11 +22,11 @@
 #include <cstring>
 #include <functional>
 #include <limits>
+#include <optional>
 #include <type_traits>
 #include <utility>
 
 #include "perfetto/base/compiler.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/trace_processor/trace_blob.h"
 #include "perfetto/trace_processor/trace_blob_view.h"
 #include "src/trace_processor/importers/common/parser_types.h"
diff --git a/src/trace_processor/sorter/trace_token_buffer.h b/src/trace_processor/sorter/trace_token_buffer.h
index a222bbc..85af6ac 100644
--- a/src/trace_processor/sorter/trace_token_buffer.h
+++ b/src/trace_processor/sorter/trace_token_buffer.h
@@ -19,12 +19,12 @@
 
 #include <cstdint>
 #include <limits>
+#include <optional>
 #include <utility>
 #include <vector>
 
 #include "perfetto/base/compiler.h"
 #include "perfetto/ext/base/circular_queue.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/utils.h"
 #include "perfetto/trace_processor/trace_blob.h"
 #include "perfetto/trace_processor/trace_blob_view.h"
diff --git a/src/trace_processor/sorter/trace_token_buffer_unittest.cc b/src/trace_processor/sorter/trace_token_buffer_unittest.cc
index 7d6292f..a8657d2 100644
--- a/src/trace_processor/sorter/trace_token_buffer_unittest.cc
+++ b/src/trace_processor/sorter/trace_token_buffer_unittest.cc
@@ -16,8 +16,9 @@
 
 #include "src/trace_processor/sorter/trace_token_buffer.h"
 
+#include <optional>
+
 #include "perfetto/base/compiler.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/trace_processor/trace_blob.h"
 #include "perfetto/trace_processor/trace_blob_view.h"
 #include "src/trace_processor/importers/common/parser_types.h"
@@ -145,7 +146,7 @@
   ASSERT_EQ(extracted.trace_packet_data.sequence_state,
             state.current_generation());
   ASSERT_EQ(extracted.thread_instruction_count, 123);
-  ASSERT_EQ(extracted.thread_timestamp, base::nullopt);
+  ASSERT_EQ(extracted.thread_timestamp, std::nullopt);
   ASSERT_DOUBLE_EQ(extracted.counter_value, 0.0);
   ASSERT_EQ(extracted.extra_counter_values, counter_array);
 }
diff --git a/src/trace_processor/sqlite/db_sqlite_table.cc b/src/trace_processor/sqlite/db_sqlite_table.cc
index 552a24b..a97ec8f 100644
--- a/src/trace_processor/sqlite/db_sqlite_table.cc
+++ b/src/trace_processor/sqlite/db_sqlite_table.cc
@@ -28,7 +28,7 @@
 
 namespace {
 
-base::Optional<FilterOp> SqliteOpToFilterOp(int sqlite_op) {
+std::optional<FilterOp> SqliteOpToFilterOp(int sqlite_op) {
   switch (sqlite_op) {
     case SQLITE_INDEX_CONSTRAINT_EQ:
     case SQLITE_INDEX_CONSTRAINT_IS:
@@ -54,7 +54,7 @@
     // TODO(lalitm): start supporting these constraints.
     case SQLITE_INDEX_CONSTRAINT_LIMIT:
     case SQLITE_INDEX_CONSTRAINT_OFFSET:
-      return base::nullopt;
+      return std::nullopt;
     default:
       PERFETTO_FATAL("Currently unsupported constraint");
   }
@@ -221,10 +221,10 @@
 
   const auto& cs = qc.constraints();
   for (uint32_t i = 0; i < cs.size(); ++i) {
-    // SqliteOpToFilterOp will return nullopt for any constraint which we don't
-    // support filtering ourselves. Only omit filtering by SQLite when we can
-    // handle filtering.
-    base::Optional<FilterOp> opt_op = SqliteOpToFilterOp(cs[i].op);
+    // SqliteOpToFilterOp will return std::nullopt for any constraint which we
+    // don't support filtering ourselves. Only omit filtering by SQLite when we
+    // can handle filtering.
+    std::optional<FilterOp> opt_op = SqliteOpToFilterOp(cs[i].op);
     info->sqlite_omit_constraint[i] = opt_op.has_value();
   }
 
@@ -458,7 +458,7 @@
                                   FilterHistory history) {
   // Clear out the iterator before filtering to ensure the destructor is run
   // before the table's destructor.
-  iterator_ = base::nullopt;
+  iterator_ = std::nullopt;
 
   // We reuse this vector to reduce memory allocations on nested subqueries.
   constraints_.resize(qc.constraints().size());
@@ -467,9 +467,9 @@
     const auto& cs = qc.constraints()[i];
     uint32_t col = static_cast<uint32_t>(cs.column);
 
-    // If we get a nullopt FilterOp, that means we should allow SQLite
+    // If we get a std::nullopt FilterOp, that means we should allow SQLite
     // to handle the constraint.
-    base::Optional<FilterOp> opt_op = SqliteOpToFilterOp(cs.op);
+    std::optional<FilterOp> opt_op = SqliteOpToFilterOp(cs.op);
     if (!opt_op)
       continue;
 
@@ -617,9 +617,8 @@
     // TODO(lalitm): investigate some other criteria where it is beneficial
     // to have a fast path and expand to them.
     mode_ = Mode::kSingleRow;
-    single_row_ = filter_map.size() == 1
-                      ? base::make_optional(filter_map.Get(0))
-                      : base::nullopt;
+    single_row_ = filter_map.size() == 1 ? std::make_optional(filter_map.Get(0))
+                                         : std::nullopt;
     eof_ = !single_row_.has_value();
   } else {
     mode_ = Mode::kTable;
diff --git a/src/trace_processor/sqlite/db_sqlite_table.h b/src/trace_processor/sqlite/db_sqlite_table.h
index 4b50e6d..6a2282d 100644
--- a/src/trace_processor/sqlite/db_sqlite_table.h
+++ b/src/trace_processor/sqlite/db_sqlite_table.h
@@ -82,11 +82,11 @@
     std::unique_ptr<Table> dynamic_table_;
 
     // Only valid for Mode::kSingleRow.
-    base::Optional<uint32_t> single_row_;
+    std::optional<uint32_t> single_row_;
 
     // Only valid for Mode::kTable.
-    base::Optional<Table> db_table_;
-    base::Optional<Table::Iterator> iterator_;
+    std::optional<Table> db_table_;
+    std::optional<Table::Iterator> iterator_;
 
     bool eof_ = true;
 
diff --git a/src/trace_processor/sqlite/query_cache.h b/src/trace_processor/sqlite/query_cache.h
index 16a2b6e..f3b8223 100644
--- a/src/trace_processor/sqlite/query_cache.h
+++ b/src/trace_processor/sqlite/query_cache.h
@@ -16,8 +16,7 @@
 
 #ifndef SRC_TRACE_PROCESSOR_SQLITE_QUERY_CACHE_H_
 #define SRC_TRACE_PROCESSOR_SQLITE_QUERY_CACHE_H_
-
-#include "perfetto/ext/base/optional.h"
+#include <optional>
 
 #include "src/trace_processor/db/table.h"
 #include "src/trace_processor/sqlite/query_constraints.h"
diff --git a/src/trace_processor/sqlite/sqlite_raw_table.cc b/src/trace_processor/sqlite/sqlite_raw_table.cc
index f6f0945..feaca00 100644
--- a/src/trace_processor/sqlite/sqlite_raw_table.cc
+++ b/src/trace_processor/sqlite/sqlite_raw_table.cc
@@ -60,7 +60,7 @@
   ArgsSerializer(TraceProcessorContext*,
                  ArgSetId arg_set_id,
                  NullTermStringView event_name,
-                 std::vector<base::Optional<uint32_t>>* field_id_to_arg_index,
+                 std::vector<std::optional<uint32_t>>* field_id_to_arg_index,
                  base::StringWriter*);
 
   void SerializeArgs();
@@ -71,7 +71,7 @@
 
   // Arg writing functions.
   void WriteArgForField(uint32_t field_id, ValueWriter writer) {
-    base::Optional<uint32_t> row = FieldIdToRow(field_id);
+    std::optional<uint32_t> row = FieldIdToRow(field_id);
     if (!row)
       return;
     WriteArgAtRow(*row, writer);
@@ -79,7 +79,7 @@
   void WriteArgForField(uint32_t field_id,
                         base::StringView key,
                         ValueWriter writer) {
-    base::Optional<uint32_t> row = FieldIdToRow(field_id);
+    std::optional<uint32_t> row = FieldIdToRow(field_id);
     if (!row)
       return;
     WriteArg(key, storage_->GetArgValue(*row), writer);
@@ -93,7 +93,7 @@
 
   // Value writing functions.
   void WriteValueForField(uint32_t field_id, ValueWriter writer) {
-    base::Optional<uint32_t> row = FieldIdToRow(field_id);
+    std::optional<uint32_t> row = FieldIdToRow(field_id);
     if (!row)
       return;
     writer(storage_->GetArgValue(*row));
@@ -116,21 +116,21 @@
   }
 
   // Converts a field id to a row in the args table.
-  base::Optional<uint32_t> FieldIdToRow(uint32_t field_id) {
+  std::optional<uint32_t> FieldIdToRow(uint32_t field_id) {
     PERFETTO_DCHECK(field_id > 0);
     PERFETTO_DCHECK(field_id < field_id_to_arg_index_->size());
-    base::Optional<uint32_t> index_in_arg_set =
+    std::optional<uint32_t> index_in_arg_set =
         (*field_id_to_arg_index_)[field_id];
     return index_in_arg_set.has_value()
-               ? base::make_optional(start_row_ + *index_in_arg_set)
-               : base::nullopt;
+               ? std::make_optional(start_row_ + *index_in_arg_set)
+               : std::nullopt;
   }
 
   const TraceStorage* storage_ = nullptr;
   TraceProcessorContext* context_ = nullptr;
   ArgSetId arg_set_id_ = kInvalidArgSetId;
   NullTermStringView event_name_;
-  std::vector<base::Optional<uint32_t>>* field_id_to_arg_index_;
+  std::vector<std::optional<uint32_t>>* field_id_to_arg_index_;
 
   RowMap row_map_;
   uint32_t start_row_ = 0;
@@ -142,7 +142,7 @@
     TraceProcessorContext* context,
     ArgSetId arg_set_id,
     NullTermStringView event_name,
-    std::vector<base::Optional<uint32_t>>* field_id_to_arg_index,
+    std::vector<std::optional<uint32_t>>* field_id_to_arg_index,
     base::StringWriter* writer)
     : context_(context),
       arg_set_id_(arg_set_id),
@@ -205,7 +205,7 @@
     WriteArgForField(SS::kPrevStateFieldNumber, [this](const Variadic& value) {
       PERFETTO_DCHECK(value.type == Variadic::Type::kInt);
       auto state = static_cast<uint16_t>(value.int_value);
-      base::Optional<VersionNumber> kernel_version =
+      std::optional<VersionNumber> kernel_version =
           SystemInfoTracker::GetOrCreate(context_)->GetKernelVersion();
       writer_->AppendString(
           ftrace_utils::TaskState::FromRawPrevState(state, kernel_version)
diff --git a/src/trace_processor/sqlite/sqlite_raw_table.h b/src/trace_processor/sqlite/sqlite_raw_table.h
index a3ec5c2..dcb5c46 100644
--- a/src/trace_processor/sqlite/sqlite_raw_table.h
+++ b/src/trace_processor/sqlite/sqlite_raw_table.h
@@ -38,7 +38,7 @@
 
  private:
   using StringIdMap =
-      base::FlatHashMap<StringId, std::vector<base::Optional<uint32_t>>>;
+      base::FlatHashMap<StringId, std::vector<std::optional<uint32_t>>>;
 
   void SerializePrefix(uint32_t raw_row, base::StringWriter* writer);
 
diff --git a/src/trace_processor/sqlite/sqlite_table.h b/src/trace_processor/sqlite/sqlite_table.h
index 2d9ed50..de94669 100644
--- a/src/trace_processor/sqlite/sqlite_table.h
+++ b/src/trace_processor/sqlite/sqlite_table.h
@@ -22,11 +22,11 @@
 #include <functional>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/utils.h"
 #include "perfetto/trace_processor/basic_types.h"
 #include "src/trace_processor/sqlite/query_constraints.h"
diff --git a/src/trace_processor/sqlite/sqlite_utils.cc b/src/trace_processor/sqlite/sqlite_utils.cc
index 475b1d4..c4077a5 100644
--- a/src/trace_processor/sqlite/sqlite_utils.cc
+++ b/src/trace_processor/sqlite/sqlite_utils.cc
@@ -196,9 +196,9 @@
 
 template <typename T>
 base::Status ExtractFromSqlValueInt(const SqlValue& value,
-                                    base::Optional<T>& out) {
+                                    std::optional<T>& out) {
   if (value.is_null()) {
-    out = base::nullopt;
+    out = std::nullopt;
     return base::OkStatus();
   }
   if (value.type != SqlValue::kLong) {
@@ -221,21 +221,21 @@
 }
 
 base::Status ExtractFromSqlValue(const SqlValue& value,
-                                 base::Optional<int64_t>& out) {
+                                 std::optional<int64_t>& out) {
   return ExtractFromSqlValueInt(value, out);
 }
 base::Status ExtractFromSqlValue(const SqlValue& value,
-                                 base::Optional<int32_t>& out) {
+                                 std::optional<int32_t>& out) {
   return ExtractFromSqlValueInt(value, out);
 }
 base::Status ExtractFromSqlValue(const SqlValue& value,
-                                 base::Optional<uint32_t>& out) {
+                                 std::optional<uint32_t>& out) {
   return ExtractFromSqlValueInt(value, out);
 }
 base::Status ExtractFromSqlValue(const SqlValue& value,
-                                 base::Optional<double>& out) {
+                                 std::optional<double>& out) {
   if (value.is_null()) {
-    out = base::nullopt;
+    out = std::nullopt;
     return base::OkStatus();
   }
   if (value.type != SqlValue::kDouble) {
@@ -248,9 +248,9 @@
   return base::OkStatus();
 }
 base::Status ExtractFromSqlValue(const SqlValue& value,
-                                 base::Optional<const char*>& out) {
+                                 std::optional<const char*>& out) {
   if (value.is_null()) {
-    out = base::nullopt;
+    out = std::nullopt;
     return base::OkStatus();
   }
   if (value.type != SqlValue::kString) {
diff --git a/src/trace_processor/sqlite/sqlite_utils.h b/src/trace_processor/sqlite/sqlite_utils.h
index c3b08bb..ef44c45 100644
--- a/src/trace_processor/sqlite/sqlite_utils.h
+++ b/src/trace_processor/sqlite/sqlite_utils.h
@@ -22,11 +22,11 @@
 #include <bitset>
 #include <cstddef>
 #include <cstring>
+#include <optional>
 #include <utility>
 
 #include "perfetto/base/logging.h"
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/status_or.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/string_view.h"
@@ -98,7 +98,7 @@
   return sql_value;
 }
 
-inline base::Optional<std::string> SqlValueToString(SqlValue value) {
+inline std::optional<std::string> SqlValueToString(SqlValue value) {
   switch (value.type) {
     case SqlValue::Type::kString:
       return value.AsString();
@@ -108,7 +108,7 @@
       return std::to_string(value.AsLong());
     case SqlValue::Type::kBytes:
     case SqlValue::Type::kNull:
-      return base::nullopt;
+      return std::nullopt;
   }
   PERFETTO_FATAL("For GCC");
 }
@@ -169,7 +169,7 @@
 }
 
 inline base::Status FormatErrorMessage(sqlite3_stmt* stmt,
-                                       base::Optional<base::StringView> sql,
+                                       std::optional<base::StringView> sql,
                                        sqlite3* db,
                                        int error_code) {
   if (stmt) {
@@ -209,7 +209,7 @@
   if (err != SQLITE_DONE) {
     auto db = sqlite3_db_handle(stmt);
     return base::ErrStatus(
-        "%s", FormatErrorMessage(stmt, base::nullopt, db, err).c_message());
+        "%s", FormatErrorMessage(stmt, std::nullopt, db, err).c_message());
   }
   return base::OkStatus();
 }
@@ -228,21 +228,20 @@
 
 // Exracts the given type from the SqlValue if |value| can fit
 // in the provided optional. Note that SqlValue::kNull will always
-// succeed and cause base::nullopt to be set.
+// succeed and cause std::nullopt to be set.
 //
 // Returns base::ErrStatus if the type does not match or does not
 // fit in the width of the provided optional type (i.e. int64 value
 // not fitting in int32 optional).
 base::Status ExtractFromSqlValue(const SqlValue& value,
-                                 base::Optional<int64_t>&);
+                                 std::optional<int64_t>&);
 base::Status ExtractFromSqlValue(const SqlValue& value,
-                                 base::Optional<int32_t>&);
+                                 std::optional<int32_t>&);
 base::Status ExtractFromSqlValue(const SqlValue& value,
-                                 base::Optional<uint32_t>&);
+                                 std::optional<uint32_t>&);
+base::Status ExtractFromSqlValue(const SqlValue& value, std::optional<double>&);
 base::Status ExtractFromSqlValue(const SqlValue& value,
-                                 base::Optional<double>&);
-base::Status ExtractFromSqlValue(const SqlValue& value,
-                                 base::Optional<const char*>&);
+                                 std::optional<const char*>&);
 
 // Returns the column names for the table named by |raw_table_name|.
 base::Status GetColumnsForTable(sqlite3* db,
diff --git a/src/trace_processor/sqlite/sqlite_utils_unittest.cc b/src/trace_processor/sqlite/sqlite_utils_unittest.cc
index b52df66..be28af1 100644
--- a/src/trace_processor/sqlite/sqlite_utils_unittest.cc
+++ b/src/trace_processor/sqlite/sqlite_utils_unittest.cc
@@ -75,7 +75,7 @@
 }
 
 TEST(SqliteUtilsTest, ExtractFromSqlValueInt32) {
-  base::Optional<int32_t> int32;
+  std::optional<int32_t> int32;
 
   static constexpr int64_t kMin = std::numeric_limits<int32_t>::min();
   static constexpr int64_t kMax = std::numeric_limits<int32_t>::max();
@@ -98,7 +98,7 @@
 }
 
 TEST(SqliteUtilsTest, ExtractFromSqlValueUint32) {
-  base::Optional<uint32_t> uint32;
+  std::optional<uint32_t> uint32;
 
   static constexpr int64_t kMin = std::numeric_limits<uint32_t>::min();
   static constexpr int64_t kMax = std::numeric_limits<uint32_t>::max();
@@ -121,7 +121,7 @@
 }
 
 TEST(SqliteUtilsTest, ExtractFromSqlValueInt64) {
-  base::Optional<int64_t> int64;
+  std::optional<int64_t> int64;
 
   static constexpr int64_t kMin = std::numeric_limits<int64_t>::min();
   static constexpr int64_t kMax = std::numeric_limits<int64_t>::max();
@@ -143,7 +143,7 @@
 }
 
 TEST(SqliteUtilsTest, ExtractFromSqlValueDouble) {
-  base::Optional<double> doub;
+  std::optional<double> doub;
 
   static constexpr double kMin = std::numeric_limits<double>::min();
   static constexpr double kMax = std::numeric_limits<double>::max();
@@ -165,7 +165,7 @@
 }
 
 TEST(SqliteUtilsTest, ExtractFromSqlValueString) {
-  base::Optional<const char*> string;
+  std::optional<const char*> string;
 
   ASSERT_TRUE(ExtractFromSqlValue(SqlValue::String("foo"), string).ok());
   ASSERT_STREQ(*string, "foo");
diff --git a/src/trace_processor/storage/trace_storage.h b/src/trace_processor/storage/trace_storage.h
index 5443165..4fe2071 100644
--- a/src/trace_processor/storage/trace_storage.h
+++ b/src/trace_processor/storage/trace_storage.h
@@ -20,6 +20,7 @@
 #include <array>
 #include <deque>
 #include <map>
+#include <optional>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -28,7 +29,6 @@
 #include "perfetto/base/logging.h"
 #include "perfetto/base/time.h"
 #include "perfetto/ext/base/hash.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/ext/base/utils.h"
 #include "perfetto/trace_processor/basic_types.h"
@@ -154,13 +154,13 @@
       return thread_instruction_deltas_;
     }
 
-    base::Optional<uint32_t> FindRowForSliceId(SliceId slice_id) const {
+    std::optional<uint32_t> FindRowForSliceId(SliceId slice_id) const {
       auto it =
           std::lower_bound(slice_ids().begin(), slice_ids().end(), slice_id);
       if (it != slice_ids().end() && *it == slice_id) {
         return static_cast<uint32_t>(std::distance(slice_ids().begin(), it));
       }
-      return base::nullopt;
+      return std::nullopt;
     }
 
     void UpdateThreadDeltasForSliceId(SliceId slice_id,
@@ -251,14 +251,14 @@
   }
 
   // Example usage: opt_cpu_failure = GetIndexedStats(stats::cpu_failure, 1);
-  base::Optional<int64_t> GetIndexedStats(size_t key, int index) {
+  std::optional<int64_t> GetIndexedStats(size_t key, int index) {
     PERFETTO_DCHECK(key < stats::kNumKeys);
     PERFETTO_DCHECK(stats::kTypes[key] == stats::kIndexed);
     auto kv = stats_[key].indexed_values.find(index);
     if (kv != stats_[key].indexed_values.end()) {
       return kv->second;
     }
-    return base::nullopt;
+    return std::nullopt;
   }
 
   class ScopedStatsTracer {
@@ -739,12 +739,12 @@
 
   util::Status ExtractArg(uint32_t arg_set_id,
                           const char* key,
-                          base::Optional<Variadic>* result) {
+                          std::optional<Variadic>* result) {
     const auto& args = arg_table();
     RowMap filtered = args.FilterToRowMap(
         {args.arg_set_id().eq(arg_set_id), args.key().eq(key)});
     if (filtered.empty()) {
-      *result = base::nullopt;
+      *result = std::nullopt;
       return util::OkStatus();
     }
     if (filtered.size() > 1) {
@@ -799,11 +799,11 @@
     return variadic_type_ids_[type];
   }
 
-  base::Optional<Variadic::Type> GetVariadicTypeForId(StringId id) const {
+  std::optional<Variadic::Type> GetVariadicTypeForId(StringId id) const {
     auto it =
         std::find(variadic_type_ids_.begin(), variadic_type_ids_.end(), id);
     if (it == variadic_type_ids_.end())
-      return base::nullopt;
+      return std::nullopt;
 
     int64_t idx = std::distance(variadic_type_ids_.begin(), it);
     return static_cast<Variadic::Type>(idx);
@@ -1003,8 +1003,8 @@
 
   result_type operator()(const argument_type& r) const {
     return std::hash<::perfetto::trace_processor::StringId>{}(r.name) ^
-           std::hash<::perfetto::base::Optional<
-               ::perfetto::trace_processor::MappingId>>{}(r.mapping) ^
+           std::hash<std::optional<::perfetto::trace_processor::MappingId>>{}(
+               r.mapping) ^
            std::hash<int64_t>{}(r.rel_pc);
   }
 };
@@ -1018,8 +1018,8 @@
 
   result_type operator()(const argument_type& r) const {
     return std::hash<int64_t>{}(r.depth) ^
-           std::hash<::perfetto::base::Optional<
-               ::perfetto::trace_processor::CallsiteId>>{}(r.parent_id) ^
+           std::hash<std::optional<::perfetto::trace_processor::CallsiteId>>{}(
+               r.parent_id) ^
            std::hash<::perfetto::trace_processor::FrameId>{}(r.frame_id);
   }
 };
diff --git a/src/trace_processor/tables/counter_tables.h b/src/trace_processor/tables/counter_tables.h
index 7df627b..69668b2 100644
--- a/src/trace_processor/tables/counter_tables.h
+++ b/src/trace_processor/tables/counter_tables.h
@@ -32,7 +32,7 @@
   C(int64_t, ts, Column::Flag::kSorted)                \
   C(CounterTrackTable::Id, track_id)                   \
   C(double, value)                                     \
-  C(base::Optional<uint32_t>, arg_set_id)
+  C(std::optional<uint32_t>, arg_set_id)
 
 }  // namespace tables
 }  // namespace trace_processor
diff --git a/src/trace_processor/tables/macros_benchmark.cc b/src/trace_processor/tables/macros_benchmark.cc
index 5df9e8c..c946696 100644
--- a/src/trace_processor/tables/macros_benchmark.cc
+++ b/src/trace_processor/tables/macros_benchmark.cc
@@ -28,7 +28,7 @@
   C(uint32_t, root_sorted, Column::Flag::kSorted)    \
   C(uint32_t, root_non_null)                         \
   C(uint32_t, root_non_null_2)                       \
-  C(base::Optional<uint32_t>, root_nullable)
+  C(std::optional<uint32_t>, root_nullable)
 
 PERFETTO_TP_TABLE(PERFETTO_TP_ROOT_TEST_TABLE);
 
@@ -37,7 +37,7 @@
   PARENT(PERFETTO_TP_ROOT_TEST_TABLE, C)           \
   C(uint32_t, child_sorted, Column::Flag::kSorted) \
   C(uint32_t, child_non_null)                      \
-  C(base::Optional<uint32_t>, child_nullable)
+  C(std::optional<uint32_t>, child_nullable)
 
 PERFETTO_TP_TABLE(PERFETTO_TP_CHILD_TABLE);
 
@@ -264,8 +264,8 @@
     uint32_t value = rnd_engine() % partitions;
 
     RootTestTable::Row row;
-    row.root_nullable = value % 2 == 0 ? perfetto::base::nullopt
-                                       : perfetto::base::make_optional(value);
+    row.root_nullable =
+        value % 2 == 0 ? std::nullopt : std::make_optional(value);
     root.Insert(row);
   }
 
@@ -310,8 +310,8 @@
     uint32_t value = rnd_engine() % partitions;
 
     ChildTestTable::Row row;
-    row.child_nullable = value % 2 == 0 ? perfetto::base::nullopt
-                                        : perfetto::base::make_optional(value);
+    row.child_nullable =
+        value % 2 == 0 ? std::nullopt : std::make_optional(value);
     root.Insert({});
     child.Insert(row);
   }
@@ -488,9 +488,8 @@
     const uint32_t root_value = static_cast<uint32_t>(rnd_engine());
 
     RootTestTable::Row row;
-    row.root_nullable = root_value % 2 == 0
-                            ? perfetto::base::nullopt
-                            : perfetto::base::make_optional(root_value);
+    row.root_nullable =
+        root_value % 2 == 0 ? std::nullopt : std::make_optional(root_value);
     root.Insert(row);
   }
 
@@ -540,17 +539,15 @@
     const uint32_t root_value = static_cast<uint32_t>(rnd_engine());
 
     RootTestTable::Row root_row;
-    root_row.root_nullable = root_value % 2 == 0
-                                 ? perfetto::base::nullopt
-                                 : perfetto::base::make_optional(root_value);
+    root_row.root_nullable =
+        root_value % 2 == 0 ? std::nullopt : std::make_optional(root_value);
     root.Insert(root_row);
 
     const uint32_t child_value = static_cast<uint32_t>(rnd_engine());
 
     ChildTestTable::Row child_row;
-    child_row.root_nullable = child_value % 2 == 0
-                                  ? perfetto::base::nullopt
-                                  : perfetto::base::make_optional(child_value);
+    child_row.root_nullable =
+        child_value % 2 == 0 ? std::nullopt : std::make_optional(child_value);
     child.Insert(child_row);
   }
 
diff --git a/src/trace_processor/tables/macros_internal.h b/src/trace_processor/tables/macros_internal.h
index 4389ce2..059e7b7 100644
--- a/src/trace_processor/tables/macros_internal.h
+++ b/src/trace_processor/tables/macros_internal.h
@@ -576,7 +576,7 @@
                                                                               \
     struct Row : parent_class_name::Row {                                     \
       /*                                                                      \
-       * Expands to Row(col_type1 col1_c, base::Optional<col_type2> col2_c,   \
+       * Expands to Row(col_type1 col1_c, std::optional<col_type2> col2_c,    \
        * ...)                                                                 \
        */                                                                     \
       Row(PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_ROW_CONSTRUCTOR)           \
@@ -841,18 +841,18 @@
     }                                                                         \
                                                                               \
     /* Returns a ConstRowReference to the row pointed to by |find_id|. */     \
-    base::Optional<ConstRowReference> FindById(Id find_id) const {            \
-      base::Optional<uint32_t> row = id().IndexOf(find_id);                   \
+    std::optional<ConstRowReference> FindById(Id find_id) const {             \
+      std::optional<uint32_t> row = id().IndexOf(find_id);                    \
       if (!row)                                                               \
-        return base::nullopt;                                                 \
+        return std::nullopt;                                                  \
       return ConstRowReference(this, *row);                                   \
     }                                                                         \
                                                                               \
     /* Returns a RowReference to the row pointed to by |find_id|. */          \
-    base::Optional<RowReference> FindById(Id find_id) {                       \
-      base::Optional<uint32_t> row = id().IndexOf(find_id);                   \
+    std::optional<RowReference> FindById(Id find_id) {                        \
+      std::optional<uint32_t> row = id().IndexOf(find_id);                    \
       if (!row)                                                               \
-        return base::nullopt;                                                 \
+        return std::nullopt;                                                  \
       return RowReference(this, *row);                                        \
     }                                                                         \
                                                                               \
diff --git a/src/trace_processor/tables/macros_unittest.cc b/src/trace_processor/tables/macros_unittest.cc
index 9844a9d..f6414cd 100644
--- a/src/trace_processor/tables/macros_unittest.cc
+++ b/src/trace_processor/tables/macros_unittest.cc
@@ -33,13 +33,13 @@
 #define PERFETTO_TP_TEST_COUNTER_TABLE_DEF(NAME, PARENT, C) \
   NAME(TestCounterTable, "counter")                         \
   PARENT(PERFETTO_TP_TEST_EVENT_TABLE_DEF, C)               \
-  C(base::Optional<double>, value)
+  C(std::optional<double>, value)
 PERFETTO_TP_TABLE(PERFETTO_TP_TEST_COUNTER_TABLE_DEF);
 
 #define PERFETTO_TP_TEST_SLICE_TABLE_DEF(NAME, PARENT, C) \
   NAME(TestSliceTable, "slice")                           \
   PARENT(PERFETTO_TP_TEST_EVENT_TABLE_DEF, C)             \
-  C(base::Optional<int64_t>, dur)                         \
+  C(std::optional<int64_t>, dur)                          \
   C(int64_t, depth)
 PERFETTO_TP_TABLE(PERFETTO_TP_TEST_SLICE_TABLE_DEF);
 
@@ -107,7 +107,7 @@
   ASSERT_EQ(slice_.dur()[0], 10);
   ASSERT_EQ(slice_.depth()[0], 0);
 
-  id = slice_.Insert(TestSliceTable::Row(210, 456, base::nullopt, 0)).id;
+  id = slice_.Insert(TestSliceTable::Row(210, 456, std::nullopt, 0)).id;
   ASSERT_EQ(id.value, 2u);
 
   ASSERT_EQ(event_.type().GetString(2), "slice");
@@ -116,7 +116,7 @@
   ASSERT_EQ(slice_.type().GetString(1), "slice");
   ASSERT_EQ(slice_.ts()[1], 210);
   ASSERT_EQ(slice_.arg_set_id()[1], 456);
-  ASSERT_EQ(slice_.dur()[1], base::nullopt);
+  ASSERT_EQ(slice_.dur()[1], std::nullopt);
   ASSERT_EQ(slice_.depth()[1], 0);
 }
 
diff --git a/src/trace_processor/tables/profiler_tables.h b/src/trace_processor/tables/profiler_tables.h
index fad8cfc..f0e84b2 100644
--- a/src/trace_processor/tables/profiler_tables.h
+++ b/src/trace_processor/tables/profiler_tables.h
@@ -34,7 +34,7 @@
   NAME(StackProfileCallsiteTable, "stack_profile_callsite")     \
   PERFETTO_TP_ROOT_TABLE(PARENT, C)                             \
   C(uint32_t, depth)                                            \
-  C(base::Optional<StackProfileCallsiteTable::Id>, parent_id)   \
+  C(std::optional<StackProfileCallsiteTable::Id>, parent_id)    \
   C(StackProfileFrameTable::Id, frame_id)
 
 }  // namespace tables
diff --git a/src/trace_processor/tables/slice_tables.h b/src/trace_processor/tables/slice_tables.h
index b82e3eb..e33ae19 100644
--- a/src/trace_processor/tables/slice_tables.h
+++ b/src/trace_processor/tables/slice_tables.h
@@ -24,23 +24,23 @@
 namespace trace_processor {
 namespace tables {
 
-#define PERFETTO_TP_SLICE_TABLE_DEF(NAME, PARENT, C)   \
-  NAME(SliceTable, "internal_slice")                   \
-  PERFETTO_TP_ROOT_TABLE(PARENT, C)                    \
-  C(int64_t, ts, Column::Flag::kSorted)                \
-  C(int64_t, dur)                                      \
-  C(TrackTable::Id, track_id)                          \
-  C(base::Optional<StringPool::Id>, category)          \
-  C(base::Optional<StringPool::Id>, name)              \
-  C(uint32_t, depth)                                   \
-  C(int64_t, stack_id)                                 \
-  C(int64_t, parent_stack_id)                          \
-  C(base::Optional<SliceTable::Id>, parent_id)         \
-  C(uint32_t, arg_set_id)                              \
-  C(base::Optional<int64_t>, thread_ts)                \
-  C(base::Optional<int64_t>, thread_dur)               \
-  C(base::Optional<int64_t>, thread_instruction_count) \
-  C(base::Optional<int64_t>, thread_instruction_delta)
+#define PERFETTO_TP_SLICE_TABLE_DEF(NAME, PARENT, C)  \
+  NAME(SliceTable, "internal_slice")                  \
+  PERFETTO_TP_ROOT_TABLE(PARENT, C)                   \
+  C(int64_t, ts, Column::Flag::kSorted)               \
+  C(int64_t, dur)                                     \
+  C(TrackTable::Id, track_id)                         \
+  C(std::optional<StringPool::Id>, category)          \
+  C(std::optional<StringPool::Id>, name)              \
+  C(uint32_t, depth)                                  \
+  C(int64_t, stack_id)                                \
+  C(int64_t, parent_stack_id)                         \
+  C(std::optional<SliceTable::Id>, parent_id)         \
+  C(uint32_t, arg_set_id)                             \
+  C(std::optional<int64_t>, thread_ts)                \
+  C(std::optional<int64_t>, thread_dur)               \
+  C(std::optional<int64_t>, thread_instruction_count) \
+  C(std::optional<int64_t>, thread_instruction_delta)
 
 #define PERFETTO_TP_SCHED_SLICE_TABLE_DEF(NAME, PARENT, C) \
   NAME(SchedSliceTable, "sched_slice")                     \
diff --git a/src/trace_processor/tables/trace_proto_tables.h b/src/trace_processor/tables/trace_proto_tables.h
index 04579ea..aa57b59 100644
--- a/src/trace_processor/tables/trace_proto_tables.h
+++ b/src/trace_processor/tables/trace_proto_tables.h
@@ -27,10 +27,10 @@
 #define PERFETTO_TP_EXPERIMENTAL_PROTO_PATH_TABLE_DEF(NAME, PARENT, C) \
   NAME(ExperimentalProtoPathTable, "experimental_proto_path")          \
   PERFETTO_TP_ROOT_TABLE(PARENT, C)                                    \
-  C(base::Optional<ExperimentalProtoPathTable::Id>, parent_id)         \
+  C(std::optional<ExperimentalProtoPathTable::Id>, parent_id)          \
   C(StringPool::Id, field_type)                                        \
-  C(base::Optional<StringPool::Id>, field_name)                        \
-  C(base::Optional<uint32_t>, arg_set_id)
+  C(std::optional<StringPool::Id>, field_name)                         \
+  C(std::optional<uint32_t>, arg_set_id)
 
 PERFETTO_TP_TABLE(PERFETTO_TP_EXPERIMENTAL_PROTO_PATH_TABLE_DEF);
 
diff --git a/src/trace_processor/trace_database_integrationtest.cc b/src/trace_processor/trace_database_integrationtest.cc
index 720389a..b675c80 100644
--- a/src/trace_processor/trace_database_integrationtest.cc
+++ b/src/trace_processor/trace_database_integrationtest.cc
@@ -16,11 +16,11 @@
 
 #include <algorithm>
 #include <map>
+#include <optional>
 #include <random>
 #include <string>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/trace_processor/trace_processor.h"
 #include "protos/perfetto/common/descriptor.pbzero.h"
diff --git a/src/trace_processor/trace_processor_impl.cc b/src/trace_processor/trace_processor_impl.cc
index 7c38b98..742d7a2 100644
--- a/src/trace_processor/trace_processor_impl.cc
+++ b/src/trace_processor/trace_processor_impl.cc
@@ -1007,7 +1007,7 @@
 }
 
 bool TraceProcessorImpl::IsRootMetricField(const std::string& metric_name) {
-  base::Optional<uint32_t> desc_idx =
+  std::optional<uint32_t> desc_idx =
       pool_.FindDescriptorIdx(".perfetto.protos.TraceMetrics");
   if (!desc_idx.has_value())
     return false;
diff --git a/src/trace_processor/trace_processor_shell.cc b/src/trace_processor/trace_processor_shell.cc
index 0a0ba23..1b02b27 100644
--- a/src/trace_processor/trace_processor_shell.cc
+++ b/src/trace_processor/trace_processor_shell.cc
@@ -13,15 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <sys/stat.h>
-
 #include <cctype>
 #include <cinttypes>
 #include <functional>
 #include <iostream>
+#include <optional>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
@@ -39,7 +40,6 @@
 #include "perfetto/ext/base/file_utils.h"
 #include "perfetto/ext/base/flat_hash_map.h"
 #include "perfetto/ext/base/getopt.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/ext/base/string_utils.h"
@@ -396,7 +396,7 @@
 
 struct MetricNameAndPath {
   std::string name;
-  base::Optional<std::string> no_ext_path;
+  std::optional<std::string> no_ext_path;
 };
 
 base::Status RunMetrics(const std::vector<MetricNameAndPath>& metrics,
@@ -1345,7 +1345,7 @@
     auto ext_idx = metric_or_path.rfind('.');
     if (ext_idx == std::string::npos) {
       name_and_path.emplace_back(
-          MetricNameAndPath{metric_or_path, base::nullopt});
+          MetricNameAndPath{metric_or_path, std::nullopt});
       continue;
     }
 
@@ -1453,7 +1453,7 @@
           PERFETTO_ELOG("%s", status.c_message());
         }
       } else if (strcmp(command, "width") == 0 && strlen(arg)) {
-        base::Optional<uint32_t> width = base::CStringToUInt32(arg);
+        std::optional<uint32_t> width = base::CStringToUInt32(arg);
         if (!width) {
           PERFETTO_ELOG("Invalid column width specified");
           continue;
diff --git a/src/trace_processor/types/gfp_flags.cc b/src/trace_processor/types/gfp_flags.cc
index acb52fb..a27ab10 100644
--- a/src/trace_processor/types/gfp_flags.cc
+++ b/src/trace_processor/types/gfp_flags.cc
@@ -215,7 +215,7 @@
 }  // namespace
 
 void WriteGfpFlag(uint64_t value,
-                  base::Optional<VersionNumber> version,
+                  std::optional<VersionNumber> version,
                   base::StringWriter* writer) {
   // On all kernel versions if this flag is not set, return GFP_NOWAIT.
   if (value == 0) {
diff --git a/src/trace_processor/types/gfp_flags.h b/src/trace_processor/types/gfp_flags.h
index fb0ae29..04936a8 100644
--- a/src/trace_processor/types/gfp_flags.h
+++ b/src/trace_processor/types/gfp_flags.h
@@ -17,7 +17,8 @@
 #ifndef SRC_TRACE_PROCESSOR_TYPES_GFP_FLAGS_H_
 #define SRC_TRACE_PROCESSOR_TYPES_GFP_FLAGS_H_
 
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "perfetto/ext/base/string_writer.h"
 #include "src/trace_processor/types/version_number.h"
 
@@ -28,7 +29,7 @@
 // the kernel version. This function writes a human readable version of the
 // flag.
 void WriteGfpFlag(uint64_t value,
-                  base::Optional<VersionNumber> version,
+                  std::optional<VersionNumber> version,
                   base::StringWriter* writer);
 
 }  // namespace trace_processor
diff --git a/src/trace_processor/types/task_state.cc b/src/trace_processor/types/task_state.cc
index c91a6a4..a13f5b9 100644
--- a/src/trace_processor/types/task_state.cc
+++ b/src/trace_processor/types/task_state.cc
@@ -27,7 +27,7 @@
 // static
 TaskState TaskState::FromRawPrevState(
     uint16_t raw_state,
-    base::Optional<VersionNumber> kernel_version) {
+    std::optional<VersionNumber> kernel_version) {
   return TaskState(raw_state, kernel_version);
 }
 
@@ -55,7 +55,7 @@
 // Note to maintainers: if changing the default kernel assumption or the 4.4
 // codepath, you'll need to update ToRawStateOnlyForSystraceConversions().
 TaskState::TaskState(uint16_t raw_state,
-                     base::Optional<VersionNumber> opt_version) {
+                     std::optional<VersionNumber> opt_version) {
   // Values up to and including 0x20 (EXIT_ZOMBIE) never changed, so map them
   // directly onto ParsedFlag (we use the same flag bits for convenience).
   parsed_ = raw_state & (0x40 - 1);
diff --git a/src/trace_processor/types/task_state.h b/src/trace_processor/types/task_state.h
index 89908dc..0662f72 100644
--- a/src/trace_processor/types/task_state.h
+++ b/src/trace_processor/types/task_state.h
@@ -19,8 +19,8 @@
 
 #include <stdint.h>
 #include <array>
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/types/version_number.h"
 
 namespace perfetto {
@@ -87,7 +87,7 @@
 
   static TaskState FromRawPrevState(
       uint16_t raw_state,
-      base::Optional<VersionNumber> kernel_version);
+      std::optional<VersionNumber> kernel_version);
   static TaskState FromSystrace(const char* state_str);
   static TaskState FromParsedFlags(uint16_t parsed_state);
 
@@ -115,7 +115,7 @@
  private:
   TaskState() = default;
   explicit TaskState(uint16_t raw_state,
-                     base::Optional<VersionNumber> kernel_version);
+                     std::optional<VersionNumber> kernel_version);
   explicit TaskState(const char* state_str);
 
   bool is_runnable() const { return !(parsed_ & ~kPreempted); }
diff --git a/src/trace_processor/types/task_state_unittests.cc b/src/trace_processor/types/task_state_unittests.cc
index decc199..e08fea2 100644
--- a/src/trace_processor/types/task_state_unittests.cc
+++ b/src/trace_processor/types/task_state_unittests.cc
@@ -25,7 +25,7 @@
 
 TEST(TaskStateUnittest, PrevStateDefaultsToKernelVersion4p4) {
   auto from_raw = [](uint16_t raw) {
-    return TaskState::FromRawPrevState(raw, base::nullopt);
+    return TaskState::FromRawPrevState(raw, std::nullopt);
   };
 
   // No kernel version -> default to 4.4
@@ -95,7 +95,7 @@
 TEST(TaskStateUnittest, PreemptedFlag) {
   // Historical TASK_STATE_MAX as of 4.4:
   {
-    TaskState state = TaskState::FromRawPrevState(0x0800, base::nullopt);
+    TaskState state = TaskState::FromRawPrevState(0x0800, std::nullopt);
     EXPECT_STREQ(state.ToString().data(), "R+");
   }
   // TASK_STATE_MAX moved due to TASK_NEW:
@@ -139,7 +139,7 @@
   auto roundtrip = [](const char* in) {
     uint16_t raw =
         TaskState::FromSystrace(in).ToRawStateOnlyForSystraceConversions();
-    return TaskState::FromRawPrevState(raw, base::nullopt).ToString('|');
+    return TaskState::FromRawPrevState(raw, std::nullopt).ToString('|');
   };
 
   EXPECT_STREQ(roundtrip("R").data(), "R");
diff --git a/src/trace_processor/util/annotated_callsites.cc b/src/trace_processor/util/annotated_callsites.cc
index 840577d..b53e3cf 100644
--- a/src/trace_processor/util/annotated_callsites.cc
+++ b/src/trace_processor/util/annotated_callsites.cc
@@ -17,8 +17,8 @@
 #include "src/trace_processor/util/annotated_callsites.h"
 
 #include <iostream>
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/tables/profiler_tables_py.h"
 #include "src/trace_processor/types/trace_processor_context.h"
 
@@ -30,13 +30,13 @@
       // String to identify trampoline frames. If the string does not exist in
       // TraceProcessor's StringPool (nullopt) then there will be no trampoline
       // frames in the trace so there is no point in adding it to the pool to do
-      // all comparisons, instead we initialize the member to nullopt and the
-      // string comparisons will all fail.
+      // all comparisons, instead we initialize the member to std::nullopt and
+      // the string comparisons will all fail.
       art_jni_trampoline_(
           context->storage->string_pool().GetId("art_jni_trampoline")) {}
 
 AnnotatedCallsites::State AnnotatedCallsites::GetState(
-    base::Optional<CallsiteId> id) {
+    std::optional<CallsiteId> id) {
   if (!id) {
     return State::kInitial;
   }
@@ -75,8 +75,8 @@
   // only the libart frames does not clean up all of the JNI-related frames.
   auto frame = *context_.storage->stack_profile_frame_table().FindById(
       callsite.frame_id());
-  // art_jni_trampoline_ could be nullopt if the string does not exist in the
-  // StringPool, but that also means no frame will ever have that name.
+  // art_jni_trampoline_ could be std::nullopt if the string does not exist in
+  // the StringPool, but that also means no frame will ever have that name.
   if (art_jni_trampoline_.has_value() &&
       frame.name() == art_jni_trampoline_.value()) {
     return {State::kKeepNext, CallsiteAnnotation::kCommonFrame};
diff --git a/src/trace_processor/util/annotated_callsites.h b/src/trace_processor/util/annotated_callsites.h
index 0fbb555..e68683c 100644
--- a/src/trace_processor/util/annotated_callsites.h
+++ b/src/trace_processor/util/annotated_callsites.h
@@ -17,8 +17,9 @@
 #ifndef SRC_TRACE_PROCESSOR_UTIL_ANNOTATED_CALLSITES_H_
 #define SRC_TRACE_PROCESSOR_UTIL_ANNOTATED_CALLSITES_H_
 
+#include <optional>
+
 #include <unordered_map>
-#include "perfetto/ext/base/optional.h"
 #include "src/trace_processor/containers/string_pool.h"
 #include "src/trace_processor/storage/trace_storage.h"
 
@@ -71,7 +72,7 @@
   // mode, based on the mapping.
   enum class State { kInitial, kEraseLibart, kKeepNext };
 
-  State GetState(base::Optional<CallsiteId> id);
+  State GetState(std::optional<CallsiteId> id);
 
   std::pair<State, CallsiteAnnotation> Get(
       const tables::StackProfileCallsiteTable::ConstRowReference& callsite);
@@ -80,7 +81,7 @@
   MapType ClassifyMap(NullTermStringView map);
 
   const TraceProcessorContext& context_;
-  const base::Optional<StringPool::Id> art_jni_trampoline_;
+  const std::optional<StringPool::Id> art_jni_trampoline_;
 
   std::unordered_map<MappingId, MapType> map_types_;
   std::unordered_map<CallsiteId, State> states_;
diff --git a/src/trace_processor/util/bump_allocator.cc b/src/trace_processor/util/bump_allocator.cc
index 1469525..48cf16d 100644
--- a/src/trace_processor/util/bump_allocator.cc
+++ b/src/trace_processor/util/bump_allocator.cc
@@ -15,11 +15,12 @@
  */
 
 #include "src/trace_processor/util/bump_allocator.h"
+
 #include <limits>
+#include <optional>
 
 #include "perfetto/base/compiler.h"
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/utils.h"
 
 namespace perfetto {
@@ -55,7 +56,7 @@
 
   // Fast path: check if we have space to service this allocation in the current
   // chunk.
-  base::Optional<AllocId> alloc_id = TryAllocInLastChunk(size);
+  std::optional<AllocId> alloc_id = TryAllocInLastChunk(size);
   if (alloc_id) {
     return *alloc_id;
   }
@@ -113,10 +114,10 @@
   return AllocId{LastChunkIndex(), chunks_.back().bump_offset};
 }
 
-base::Optional<BumpAllocator::AllocId> BumpAllocator::TryAllocInLastChunk(
+std::optional<BumpAllocator::AllocId> BumpAllocator::TryAllocInLastChunk(
     uint32_t size) {
   if (chunks_.empty()) {
-    return base::nullopt;
+    return std::nullopt;
   }
 
   // TODO(266983484): consider switching this to bump downwards instead of
@@ -134,7 +135,7 @@
   uint32_t alloc_offset = chunk.bump_offset;
   uint32_t new_bump_offset = chunk.bump_offset + size;
   if (new_bump_offset > kChunkSize) {
-    return base::nullopt;
+    return std::nullopt;
   }
 
   // Set the new offset equal to the end of this allocation and increment the
diff --git a/src/trace_processor/util/bump_allocator.h b/src/trace_processor/util/bump_allocator.h
index b7b3499..985b5bc 100644
--- a/src/trace_processor/util/bump_allocator.h
+++ b/src/trace_processor/util/bump_allocator.h
@@ -22,9 +22,10 @@
 #include <cstring>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <tuple>
+
 #include "perfetto/ext/base/circular_queue.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/utils.h"
 
 namespace perfetto {
@@ -165,8 +166,8 @@
   };
 
   // Tries to allocate |size| bytes in the final chunk in |chunks_|. Returns
-  // an AllocId if this was successful or base::nullopt otherwise.
-  base::Optional<AllocId> TryAllocInLastChunk(uint32_t size);
+  // an AllocId if this was successful or std::nullopt otherwise.
+  std::optional<AllocId> TryAllocInLastChunk(uint32_t size);
 
   uint64_t ChunkIndexToQueueIndex(uint64_t chunk_index) const {
     return chunk_index - erased_front_chunks_count_;
diff --git a/src/trace_processor/util/descriptors.cc b/src/trace_processor/util/descriptors.cc
index 16cbd66..98029da 100644
--- a/src/trace_processor/util/descriptors.cc
+++ b/src/trace_processor/util/descriptors.cc
@@ -46,7 +46,7 @@
       f_decoder.label() == FieldDescriptorProto::LABEL_REPEATED, is_extension);
 }
 
-base::Optional<uint32_t> DescriptorPool::ResolveShortType(
+std::optional<uint32_t> DescriptorPool::ResolveShortType(
     const std::string& parent_path,
     const std::string& short_type) {
   PERFETTO_DCHECK(!short_type.empty());
@@ -59,7 +59,7 @@
     return opt_idx;
 
   if (parent_path.empty())
-    return base::nullopt;
+    return std::nullopt;
 
   auto parent_dot_idx = parent_path.rfind('.');
   auto parent_substr = parent_dot_idx == std::string::npos
@@ -95,7 +95,7 @@
 util::Status DescriptorPool::AddNestedProtoDescriptors(
     const std::string& file_name,
     const std::string& package_name,
-    base::Optional<uint32_t> parent_idx,
+    std::optional<uint32_t> parent_idx,
     protozero::ConstBytes descriptor_proto,
     std::vector<ExtensionInfo>* extensions,
     bool merge_existing_messages) {
@@ -166,7 +166,7 @@
 util::Status DescriptorPool::AddEnumProtoDescriptors(
     const std::string& file_name,
     const std::string& package_name,
-    base::Optional<uint32_t> parent_idx,
+    std::optional<uint32_t> parent_idx,
     protozero::ConstBytes descriptor_proto,
     bool merge_existing_messages) {
   protos::pbzero::EnumDescriptorProto::Decoder decoder(descriptor_proto);
@@ -186,7 +186,7 @@
   if (!prev_idx.has_value()) {
     ProtoDescriptor proto_descriptor(file_name, package_name, full_name,
                                      ProtoDescriptor::Type::kEnum,
-                                     base::nullopt);
+                                     std::nullopt);
     prev_idx = AddProtoDescriptor(std::move(proto_descriptor));
   }
   ProtoDescriptor& proto_descriptor = descriptors_[*prev_idx];
@@ -226,13 +226,12 @@
     std::string package = "." + base::StringView(file.package()).ToStdString();
     for (auto message_it = file.message_type(); message_it; ++message_it) {
       RETURN_IF_ERROR(AddNestedProtoDescriptors(
-          file_name, package, base::nullopt, *message_it, &extensions,
+          file_name, package, std::nullopt, *message_it, &extensions,
           merge_existing_messages));
     }
     for (auto enum_it = file.enum_type(); enum_it; ++enum_it) {
-      RETURN_IF_ERROR(AddEnumProtoDescriptors(file_name, package, base::nullopt,
-                                              *enum_it,
-                                              merge_existing_messages));
+      RETURN_IF_ERROR(AddEnumProtoDescriptors(
+          file_name, package, std::nullopt, *enum_it, merge_existing_messages));
     }
     for (auto ext_it = file.extension(); ext_it; ++ext_it) {
       extensions.emplace_back(package, *ext_it);
@@ -271,11 +270,11 @@
   return util::OkStatus();
 }
 
-base::Optional<uint32_t> DescriptorPool::FindDescriptorIdx(
+std::optional<uint32_t> DescriptorPool::FindDescriptorIdx(
     const std::string& full_name) const {
   auto it = full_name_to_descriptor_index_.find(full_name);
   if (it == full_name_to_descriptor_index_.end()) {
-    return base::nullopt;
+    return std::nullopt;
   }
   return it->second;
 }
@@ -317,7 +316,7 @@
                                  std::string package_name,
                                  std::string full_name,
                                  Type type,
-                                 base::Optional<uint32_t> parent_id)
+                                 std::optional<uint32_t> parent_id)
     : file_name_(std::move(file_name)),
       package_name_(std::move(package_name)),
       full_name_(std::move(full_name)),
diff --git a/src/trace_processor/util/descriptors.h b/src/trace_processor/util/descriptors.h
index 71dd5cc..33dbcf0 100644
--- a/src/trace_processor/util/descriptors.h
+++ b/src/trace_processor/util/descriptors.h
@@ -18,13 +18,13 @@
 #define SRC_TRACE_PROCESSOR_UTIL_DESCRIPTORS_H_
 
 #include <algorithm>
+#include <optional>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "protos/perfetto/common/descriptor.pbzero.h"
 
 namespace protozero {
@@ -77,7 +77,7 @@
                   std::string package_name,
                   std::string full_name,
                   Type type,
-                  base::Optional<uint32_t> parent_id);
+                  std::optional<uint32_t> parent_id);
 
   void AddField(FieldDescriptor descriptor) {
     PERFETTO_DCHECK(type_ == Type::kMessage);
@@ -114,18 +114,18 @@
     return &it->second;
   }
 
-  base::Optional<std::string> FindEnumString(const int32_t value) const {
+  std::optional<std::string> FindEnumString(const int32_t value) const {
     PERFETTO_DCHECK(type_ == Type::kEnum);
     auto it = enum_names_by_value_.find(value);
-    return it == enum_names_by_value_.end() ? base::nullopt
-                                            : base::make_optional(it->second);
+    return it == enum_names_by_value_.end() ? std::nullopt
+                                            : std::make_optional(it->second);
   }
 
-  base::Optional<int32_t> FindEnumValue(const std::string& value) const {
+  std::optional<int32_t> FindEnumValue(const std::string& value) const {
     PERFETTO_DCHECK(type_ == Type::kEnum);
     auto it = enum_values_by_name_.find(value);
-    return it == enum_values_by_name_.end() ? base::nullopt
-                                            : base::make_optional(it->second);
+    return it == enum_values_by_name_.end() ? std::nullopt
+                                            : std::make_optional(it->second);
   }
 
   const std::string& file_name() const { return file_name_; }
@@ -148,7 +148,7 @@
   std::string package_name_;
   std::string full_name_;
   const Type type_;
-  base::Optional<uint32_t> parent_id_;
+  std::optional<uint32_t> parent_id_;
   std::unordered_map<uint32_t, FieldDescriptor> fields_;
   std::unordered_map<int32_t, std::string> enum_names_by_value_;
   std::unordered_map<std::string, int32_t> enum_values_by_name_;
@@ -166,8 +166,7 @@
       const std::vector<std::string>& skip_prefixes = {},
       bool merge_existing_messages = false);
 
-  base::Optional<uint32_t> FindDescriptorIdx(
-      const std::string& full_name) const;
+  std::optional<uint32_t> FindDescriptorIdx(const std::string& full_name) const;
 
   std::vector<uint8_t> SerializeAsDescriptorSet();
 
@@ -182,13 +181,13 @@
  private:
   base::Status AddNestedProtoDescriptors(const std::string& file_name,
                                          const std::string& package_name,
-                                         base::Optional<uint32_t> parent_idx,
+                                         std::optional<uint32_t> parent_idx,
                                          protozero::ConstBytes descriptor_proto,
                                          std::vector<ExtensionInfo>* extensions,
                                          bool merge_existing_messages);
   base::Status AddEnumProtoDescriptors(const std::string& file_name,
                                        const std::string& package_name,
-                                       base::Optional<uint32_t> parent_idx,
+                                       std::optional<uint32_t> parent_idx,
                                        protozero::ConstBytes descriptor_proto,
                                        bool merge_existing_messages);
 
@@ -197,8 +196,8 @@
 
   // Recursively searches for the given short type in all parent messages
   // and packages.
-  base::Optional<uint32_t> ResolveShortType(const std::string& parent_path,
-                                            const std::string& short_type);
+  std::optional<uint32_t> ResolveShortType(const std::string& parent_path,
+                                           const std::string& short_type);
 
   // Adds a new descriptor to the pool and returns its index. There must not be
   // already a descriptor with the same full_name in the pool.
diff --git a/src/trace_processor/util/glob.h b/src/trace_processor/util/glob.h
index 4a413bb..ab9eec9 100644
--- a/src/trace_processor/util/glob.h
+++ b/src/trace_processor/util/glob.h
@@ -17,9 +17,9 @@
 #ifndef SRC_TRACE_PROCESSOR_UTIL_GLOB_H_
 #define SRC_TRACE_PROCESSOR_UTIL_GLOB_H_
 
+#include <optional>
 #include <vector>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/small_vector.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/ext/base/string_view.h"
diff --git a/src/trace_processor/util/profile_builder.cc b/src/trace_processor/util/profile_builder.cc
index bb99c71..8856825 100644
--- a/src/trace_processor/util/profile_builder.cc
+++ b/src/trace_processor/util/profile_builder.cc
@@ -20,10 +20,10 @@
 #include <deque>
 #include <iostream>
 #include <iterator>
+#include <optional>
 #include <vector>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/ext/trace_processor/demangle.h"
@@ -319,7 +319,7 @@
 
   const auto& cs_table = context_.storage->stack_profile_callsite_table();
 
-  base::Optional<tables::StackProfileCallsiteTable::ConstRowReference>
+  std::optional<tables::StackProfileCallsiteTable::ConstRowReference>
       start_ref = cs_table.FindById(callsite_id);
   if (!start_ref) {
     return location_ids;
@@ -329,7 +329,7 @@
       start_ref->frame_id(), annotated ? annotations_.GetAnnotation(*start_ref)
                                        : CallsiteAnnotation::kNone));
 
-  base::Optional<CallsiteId> parent_id = start_ref->parent_id();
+  std::optional<CallsiteId> parent_id = start_ref->parent_id();
   while (parent_id) {
     auto parent_ref = cs_table.FindById(*parent_id);
     location_ids.Append(WriteLocationIfNeeded(
@@ -428,7 +428,7 @@
 }
 
 std::vector<GProfileBuilder::Line> GProfileBuilder::GetLinesForSymbolSetId(
-    base::Optional<uint32_t> symbol_set_id,
+    std::optional<uint32_t> symbol_set_id,
     CallsiteAnnotation annotation,
     uint64_t mapping_id) {
   if (!symbol_set_id) {
@@ -601,7 +601,7 @@
 void GProfileBuilder::WriteMappings() {
   // The convention in pprof files is to write the mapping for the main binary
   // first. So lets do just that.
-  base::Optional<uint64_t> main_mapping_id = GuessMainBinary();
+  std::optional<uint64_t> main_mapping_id = GuessMainBinary();
   if (main_mapping_id) {
     WriteMapping(*main_mapping_id);
   }
@@ -615,7 +615,7 @@
   }
 }
 
-base::Optional<uint64_t> GProfileBuilder::GuessMainBinary() const {
+std::optional<uint64_t> GProfileBuilder::GuessMainBinary() const {
   std::vector<int64_t> mapping_scores;
 
   for (const auto& mapping : mappings_) {
@@ -625,7 +625,7 @@
   auto it = std::max_element(mapping_scores.begin(), mapping_scores.end());
 
   if (it == mapping_scores.end()) {
-    return base::nullopt;
+    return std::nullopt;
   }
 
   return static_cast<uint64_t>(std::distance(mapping_scores.begin(), it) + 1);
diff --git a/src/trace_processor/util/profile_builder.h b/src/trace_processor/util/profile_builder.h
index 8e24cb9..cfd5406 100644
--- a/src/trace_processor/util/profile_builder.h
+++ b/src/trace_processor/util/profile_builder.h
@@ -17,7 +17,8 @@
 #ifndef SRC_TRACE_PROCESSOR_UTIL_PROFILE_BUILDER_H_
 #define SRC_TRACE_PROCESSOR_UTIL_PROFILE_BUILDER_H_
 
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/protozero/packed_repeated_fields.h"
 #include "perfetto/protozero/scattered_heap_buffer.h"
@@ -257,7 +258,7 @@
       bool annotated);
 
   std::vector<Line> GetLinesForSymbolSetId(
-      base::Optional<uint32_t> symbol_set_id,
+      std::optional<uint32_t> symbol_set_id,
       CallsiteAnnotation annotation,
       uint64_t mapping_id);
 
@@ -306,7 +307,7 @@
 
   // Goes over the list of staged mappings and tries to determine which is the
   // most likely main binary.
-  base::Optional<uint64_t> GuessMainBinary() const;
+  std::optional<uint64_t> GuessMainBinary() const;
 
   bool AddSample(const protozero::PackedVarInt& location_ids,
                  const protozero::PackedVarInt& values);
diff --git a/src/trace_processor/util/proto_profiler.cc b/src/trace_processor/util/proto_profiler.cc
index 1bcd3ff..d093de2 100644
--- a/src/trace_processor/util/proto_profiler.cc
+++ b/src/trace_processor/util/proto_profiler.cc
@@ -91,8 +91,8 @@
   field_path_.emplace_back(0, nullptr, root_message_idx_, descriptor);
 }
 
-base::Optional<size_t> SizeProfileComputer::GetNext() {
-  base::Optional<size_t> result;
+std::optional<size_t> SizeProfileComputer::GetNext() {
+  std::optional<size_t> result;
   if (state_stack_.empty())
     return result;
 
diff --git a/src/trace_processor/util/proto_profiler.h b/src/trace_processor/util/proto_profiler.h
index ebc3670..a5375de 100644
--- a/src/trace_processor/util/proto_profiler.h
+++ b/src/trace_processor/util/proto_profiler.h
@@ -78,9 +78,9 @@
   // TODO(kraskevich): consider switching to internal DescriptorPool.
   void Reset(const uint8_t* ptr, size_t size);
 
-  // Returns the next sample size, or nullopt if data is exhausted. The
+  // Returns the next sample size, or std::nullopt if data is exhausted. The
   // associated path can be queried with GetPath().
-  base::Optional<size_t> GetNext();
+  std::optional<size_t> GetNext();
 
   // Returns the field path associated with the last sample returned by
   // GetNext().
diff --git a/src/trace_processor/util/proto_to_args_parser.cc b/src/trace_processor/util/proto_to_args_parser.cc
index b462d3a..61a8d78 100644
--- a/src/trace_processor/util/proto_to_args_parser.cc
+++ b/src/trace_processor/util/proto_to_args_parser.cc
@@ -50,8 +50,8 @@
     : key_(other.key_),
       old_flat_key_length_(other.old_flat_key_length_),
       old_key_length_(other.old_key_length_) {
-  other.old_flat_key_length_ = base::nullopt;
-  other.old_key_length_ = base::nullopt;
+  other.old_flat_key_length_ = std::nullopt;
+  other.old_key_length_ = std::nullopt;
 }
 
 ProtoToArgsParser::ScopedNestedKeyContext::~ScopedNestedKeyContext() {
@@ -63,8 +63,8 @@
     key_.flat_key.resize(old_flat_key_length_.value());
   if (old_key_length_)
     key_.key.resize(old_key_length_.value());
-  old_flat_key_length_ = base::nullopt;
-  old_key_length_ = base::nullopt;
+  old_flat_key_length_ = std::nullopt;
+  old_key_length_ = std::nullopt;
 }
 
 ProtoToArgsParser::Delegate::~Delegate() = default;
@@ -171,7 +171,7 @@
 
   // If we have an override parser then use that instead and move onto the
   // next loop.
-  if (base::Optional<base::Status> status =
+  if (std::optional<base::Status> status =
           MaybeApplyOverrideForField(field, delegate)) {
     return *status;
   }
@@ -200,23 +200,23 @@
   type_overrides_[type] = std::move(func);
 }
 
-base::Optional<base::Status> ProtoToArgsParser::MaybeApplyOverrideForField(
+std::optional<base::Status> ProtoToArgsParser::MaybeApplyOverrideForField(
     const protozero::Field& field,
     Delegate& delegate) {
   auto it = field_overrides_.find(key_prefix_.flat_key);
   if (it == field_overrides_.end())
-    return base::nullopt;
+    return std::nullopt;
   return it->second(field, delegate);
 }
 
-base::Optional<base::Status> ProtoToArgsParser::MaybeApplyOverrideForType(
+std::optional<base::Status> ProtoToArgsParser::MaybeApplyOverrideForType(
     const std::string& message_type,
     ScopedNestedKeyContext& key,
     const protozero::ConstBytes& data,
     Delegate& delegate) {
   auto it = type_overrides_.find(message_type);
   if (it == type_overrides_.end())
-    return base::nullopt;
+    return std::nullopt;
   return it->second(key, data, delegate);
 }
 
diff --git a/src/trace_processor/util/proto_to_args_parser.h b/src/trace_processor/util/proto_to_args_parser.h
index 7252a0f..be359cd 100644
--- a/src/trace_processor/util/proto_to_args_parser.h
+++ b/src/trace_processor/util/proto_to_args_parser.h
@@ -17,6 +17,8 @@
 #ifndef SRC_TRACE_PROCESSOR_UTIL_PROTO_TO_ARGS_PARSER_H_
 #define SRC_TRACE_PROCESSOR_UTIL_PROTO_TO_ARGS_PARSER_H_
 
+#include <functional>
+
 #include "perfetto/base/status.h"
 #include "perfetto/protozero/field.h"
 #include "protos/perfetto/trace/interned_data/interned_data.pbzero.h"
@@ -168,8 +170,8 @@
     struct ScopedStringAppender;
 
     Key& key_;
-    base::Optional<size_t> old_flat_key_length_ = base::nullopt;
-    base::Optional<size_t> old_key_length_ = base::nullopt;
+    std::optional<size_t> old_flat_key_length_ = std::nullopt;
+    std::optional<size_t> old_key_length_ = std::nullopt;
   };
 
   // These methods can be called from parsing overrides to enter nested
@@ -179,14 +181,14 @@
   ScopedNestedKeyContext EnterArray(size_t index);
 
   using ParsingOverrideForField =
-      std::function<base::Optional<base::Status>(const protozero::Field&,
-                                                 Delegate& delegate)>;
+      std::function<std::optional<base::Status>(const protozero::Field&,
+                                                Delegate& delegate)>;
 
   // Installs an override for the field at the specified path. We will invoke
   // |parsing_override| when the field is encountered.
   //
   // The return value of |parsing_override| indicates whether the override
-  // parsed the sub-message and ProtoToArgsParser should skip it (base::nullopt)
+  // parsed the sub-message and ProtoToArgsParser should skip it (std::nullopt)
   // or the sub-message should continue to be parsed by ProtoToArgsParser using
   // the descriptor (base::Status).
   //
@@ -207,7 +209,7 @@
   void AddParsingOverrideForField(const std::string& field_path,
                                   ParsingOverrideForField parsing_override);
 
-  using ParsingOverrideForType = std::function<base::Optional<base::Status>(
+  using ParsingOverrideForType = std::function<std::optional<base::Status>(
       ScopedNestedKeyContext& key,
       const protozero::ConstBytes& data,
       Delegate& delegate)>;
@@ -217,7 +219,7 @@
   // Note that the path-based overrides take precedence over type overrides.
   //
   // The return value of |parsing_override| indicates whether the override
-  // parsed the sub-message and ProtoToArgsParser should skip it (base::nullopt)
+  // parsed the sub-message and ProtoToArgsParser should skip it (std::nullopt)
   // or the sub-message should continue to be parsed by ProtoToArgsParser using
   // the descriptor (base::Status).
   //
@@ -247,11 +249,11 @@
                           Delegate& delegate,
                           int* unknown_extensions);
 
-  base::Optional<base::Status> MaybeApplyOverrideForField(
+  std::optional<base::Status> MaybeApplyOverrideForField(
       const protozero::Field&,
       Delegate& delegate);
 
-  base::Optional<base::Status> MaybeApplyOverrideForType(
+  std::optional<base::Status> MaybeApplyOverrideForType(
       const std::string& message_type,
       ScopedNestedKeyContext& key,
       const protozero::ConstBytes& data,
diff --git a/src/trace_processor/util/proto_to_args_parser_unittest.cc b/src/trace_processor/util/proto_to_args_parser_unittest.cc
index 22291ab..16120fc 100644
--- a/src/trace_processor/util/proto_to_args_parser_unittest.cc
+++ b/src/trace_processor/util/proto_to_args_parser_unittest.cc
@@ -311,7 +311,7 @@
         ++val;
         EXPECT_EQ(1, val);
         EXPECT_EQ(field.type(), protozero::proto_utils::ProtoWireType::kVarInt);
-        return base::nullopt;
+        return std::nullopt;
       });
 
   status = parser.ParseMessage(
@@ -358,13 +358,13 @@
   // multiple args rows.
   parser.AddParsingOverrideForField(
       "super_nested.value_c",
-      [](const protozero::Field& field, ProtoToArgsParser::Delegate& delegate)
-          -> base::Optional<base::Status> {
+      [](const protozero::Field& field,
+         ProtoToArgsParser::Delegate& delegate) -> std::optional<base::Status> {
         auto* decoder = delegate.GetInternedMessage(
             protos::pbzero::InternedData::kSourceLocations, field.as_uint64());
         if (!decoder) {
           // Lookup failed fall back on default behaviour.
-          return base::nullopt;
+          return std::nullopt;
         }
         delegate.AddString(ProtoToArgsParser::Key("file_name"),
                            protozero::ConstChars{"file", 4});
diff --git a/src/trace_processor/util/protozero_to_text.cc b/src/trace_processor/util/protozero_to_text.cc
index 90897ad..a7f9fcf 100644
--- a/src/trace_processor/util/protozero_to_text.cc
+++ b/src/trace_processor/util/protozero_to_text.cc
@@ -15,8 +15,8 @@
  */
 
 #include "src/trace_processor/util/protozero_to_text.h"
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/string_view.h"
 #include "perfetto/protozero/proto_decoder.h"
@@ -389,7 +389,7 @@
                              const DescriptorPool& pool,
                              std::string* indents,
                              std::string* output) {
-  base::Optional<uint32_t> opt_proto_desc_idx = pool.FindDescriptorIdx(type);
+  std::optional<uint32_t> opt_proto_desc_idx = pool.FindDescriptorIdx(type);
   const ProtoDescriptor* opt_proto_descriptor =
       opt_proto_desc_idx ? &pool.descriptors()[*opt_proto_desc_idx] : nullptr;
   const bool include_new_lines = new_lines_mode == kIncludeNewLines;
diff --git a/src/trace_processor/util/sql_argument.cc b/src/trace_processor/util/sql_argument.cc
index 3fc0b48..11cd010 100644
--- a/src/trace_processor/util/sql_argument.cc
+++ b/src/trace_processor/util/sql_argument.cc
@@ -27,7 +27,7 @@
   return std::find_if(str.begin(), str.end(), pred) == str.end();
 }
 
-base::Optional<Type> ParseType(base::StringView str) {
+std::optional<Type> ParseType(base::StringView str) {
   if (str == "BOOL") {
     return Type::kBool;
   } else if (str == "INT") {
@@ -47,7 +47,7 @@
   } else if (str == "BYTES") {
     return Type::kBytes;
   }
-  return base::nullopt;
+  return std::nullopt;
 }
 
 const char* TypeToHumanFriendlyString(sql_argument::Type type) {
diff --git a/src/trace_processor/util/sql_argument.h b/src/trace_processor/util/sql_argument.h
index 7b7b9b3..8876bed 100644
--- a/src/trace_processor/util/sql_argument.h
+++ b/src/trace_processor/util/sql_argument.h
@@ -16,9 +16,9 @@
 
 #ifndef SRC_TRACE_PROCESSOR_UTIL_SQL_ARGUMENT_H_
 #define SRC_TRACE_PROCESSOR_UTIL_SQL_ARGUMENT_H_
+#include <optional>
 
 #include "perfetto/base/status.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/trace_processor/basic_types.h"
 #include "src/trace_processor/containers/null_term_string_view.h"
 
@@ -79,8 +79,8 @@
 
 // Parses a string containing a type from SQL and converts it to a Type enum
 // value.
-// Returns base::nullopt if |type| did not correspond to any of the enum values.
-base::Optional<Type> ParseType(base::StringView type);
+// Returns std::nullopt if |type| did not correspond to any of the enum values.
+std::optional<Type> ParseType(base::StringView type);
 
 // Converts an argument type to a string for printing (e.g. in error messages
 // etc).
diff --git a/src/trace_processor/util/sql_argument_unittest.cc b/src/trace_processor/util/sql_argument_unittest.cc
index f75ceea..9f15859 100644
--- a/src/trace_processor/util/sql_argument_unittest.cc
+++ b/src/trace_processor/util/sql_argument_unittest.cc
@@ -49,7 +49,7 @@
 TEST(SqlArgumentTest, ParseType) {
   ASSERT_EQ(ParseType("PROTO"), Type::kProto);
   ASSERT_EQ(ParseType("BOOL"), Type::kBool);
-  ASSERT_EQ(ParseType("UNKNOWN"), base::nullopt);
+  ASSERT_EQ(ParseType("UNKNOWN"), std::nullopt);
   ASSERT_EQ(ParseType("UINT"), Type::kUint);
 }
 
diff --git a/src/traceconv/pprof_builder.cc b/src/traceconv/pprof_builder.cc
index 07aa6f9..1ca8654 100644
--- a/src/traceconv/pprof_builder.cc
+++ b/src/traceconv/pprof_builder.cc
@@ -159,10 +159,10 @@
   return ret;
 }
 
-base::Optional<int64_t> GetStatsEntry(
+std::optional<int64_t> GetStatsEntry(
     trace_processor::TraceProcessor* tp,
     const std::string& name,
-    base::Optional<uint64_t> idx = base::nullopt) {
+    std::optional<uint64_t> idx = std::nullopt) {
   std::string query = "select value from stats where name == '" + name + "'";
   if (idx.has_value())
     query += " and idx == " + std::to_string(idx.value());
@@ -172,12 +172,12 @@
     if (!it.Status().ok()) {
       PERFETTO_DFATAL_OR_ELOG("Invalid iterator: %s",
                               it.Status().message().c_str());
-      return base::nullopt;
+      return std::nullopt;
     }
     // some stats are not present unless non-zero
-    return base::make_optional(0);
+    return std::make_optional(0);
   }
-  return base::make_optional(it.Get(0).AsLong());
+  return std::make_optional(it.Get(0).AsLong());
 }
 
 // Interns Locations, Lines, and Functions. Interning is done by the entity's
@@ -340,9 +340,9 @@
       int64_t mapping_id = c_it.Get(2).AsLong();
       auto func_sysname = c_it.Get(3).is_null() ? "" : c_it.Get(3).AsString();
       auto func_name = c_it.Get(4).is_null() ? "" : c_it.Get(4).AsString();
-      base::Optional<int64_t> symbol_set_id =
-          c_it.Get(5).is_null() ? base::nullopt
-                                : base::make_optional(c_it.Get(5).AsLong());
+      std::optional<int64_t> symbol_set_id =
+          c_it.Get(5).is_null() ? std::nullopt
+                                : std::make_optional(c_it.Get(5).AsLong());
 
       Location loc(mapping_id, /*single_function_id=*/-1, {});
 
@@ -661,8 +661,8 @@
 
 static bool VerifyPIDStats(trace_processor::TraceProcessor* tp, uint64_t pid) {
   bool success = true;
-  base::Optional<int64_t> stat =
-      GetStatsEntry(tp, "heapprofd_buffer_corrupted", base::make_optional(pid));
+  std::optional<int64_t> stat =
+      GetStatsEntry(tp, "heapprofd_buffer_corrupted", std::make_optional(pid));
   if (!stat.has_value()) {
     PERFETTO_DFATAL_OR_ELOG("Failed to get heapprofd_buffer_corrupted stat");
   } else if (stat.value() > 0) {
@@ -673,8 +673,7 @@
                   " CLIENT MEMORY CORRUPTION.",
                   pid);
   }
-  stat =
-      GetStatsEntry(tp, "heapprofd_buffer_overran", base::make_optional(pid));
+  stat = GetStatsEntry(tp, "heapprofd_buffer_overran", std::make_optional(pid));
   if (!stat.has_value()) {
     PERFETTO_DFATAL_OR_ELOG("Failed to get heapprofd_buffer_overran stat");
   } else if (stat.value() > 0) {
@@ -861,7 +860,7 @@
 }
 
 static void LogTracePerfEventIssues(trace_processor::TraceProcessor* tp) {
-  base::Optional<int64_t> stat = GetStatsEntry(tp, "perf_samples_skipped");
+  std::optional<int64_t> stat = GetStatsEntry(tp, "perf_samples_skipped");
   if (!stat.has_value()) {
     PERFETTO_DFATAL_OR_ELOG("Failed to look up perf_samples_skipped stat");
   } else if (stat.value() > 0) {
diff --git a/src/traceconv/trace_to_hprof.cc b/src/traceconv/trace_to_hprof.cc
index d60e193..5bf1b01 100644
--- a/src/traceconv/trace_to_hprof.cc
+++ b/src/traceconv/trace_to_hprof.cc
@@ -18,6 +18,7 @@
 
 #include <algorithm>
 #include <limits>
+#include <optional>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
@@ -25,7 +26,6 @@
 
 #include "perfetto/base/logging.h"
 #include "perfetto/ext/base/endian.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "src/traceconv/utils.h"
 
@@ -141,7 +141,7 @@
 // until S.
 class RawClassData {
  public:
-  void AddClass(uint64_t id, base::Optional<uint64_t> superclass_id) {
+  void AddClass(uint64_t id, std::optional<uint64_t> superclass_id) {
     ids_.push_back(std::make_pair(id, superclass_id));
   }
 
@@ -162,7 +162,7 @@
 
  private:
   // Pair contains class ID and super class ID.
-  std::vector<std::pair<uint64_t, base::Optional<uint64_t>>> ids_;
+  std::vector<std::pair<uint64_t, std::optional<uint64_t>>> ids_;
   // Class id of the template
   std::vector<uint64_t> template_ids_;
 };
@@ -217,10 +217,10 @@
       uint64_t name_id = IngestString(dname);
 
       auto raw_super_id = it.Get(2);
-      base::Optional<uint64_t> maybe_super_id =
+      std::optional<uint64_t> maybe_super_id =
           raw_super_id.is_null()
-              ? base::nullopt
-              : base::Optional<uint64_t>(
+              ? std::nullopt
+              : std::optional<uint64_t>(
                     static_cast<uint64_t>(raw_super_id.AsLong()));
 
       std::string location(it.Get(3).AsString());
diff --git a/src/traceconv/utils.cc b/src/traceconv/utils.cc
index d223d8d..1789bc4 100644
--- a/src/traceconv/utils.cc
+++ b/src/traceconv/utils.cc
@@ -20,13 +20,13 @@
 
 #include <cinttypes>
 #include <memory>
+#include <optional>
 #include <ostream>
 #include <set>
 #include <utility>
 
 #include "perfetto/base/logging.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/protozero/scattered_heap_buffer.h"
diff --git a/src/traceconv/utils.h b/src/traceconv/utils.h
index ce9f8ce..a261774 100644
--- a/src/traceconv/utils.h
+++ b/src/traceconv/utils.h
@@ -22,10 +22,10 @@
 #include <functional>
 #include <iostream>
 #include <memory>
+#include <optional>
 #include <vector>
 
 #include "perfetto/base/build_config.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/paged_memory.h"
 #include "src/profiling/deobfuscator.h"
 
diff --git a/src/traced/probes/android_game_intervention_list/android_game_intervention_list_data_source.cc b/src/traced/probes/android_game_intervention_list/android_game_intervention_list_data_source.cc
index 527195e..b3aa454 100644
--- a/src/traced/probes/android_game_intervention_list/android_game_intervention_list_data_source.cc
+++ b/src/traced/probes/android_game_intervention_list/android_game_intervention_list_data_source.cc
@@ -17,9 +17,9 @@
 #include "src/traced/probes/android_game_intervention_list/android_game_intervention_list_data_source.h"
 
 #include <stddef.h>
+#include <optional>
 
 #include "perfetto/base/logging.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/ext/base/string_utils.h"
@@ -140,9 +140,9 @@
         break;
       }
       case 1: {
-        base::Optional<uint64_t> uid =
+        std::optional<uint64_t> uid =
             base::CStringToUInt64(string_splitter.cur_token());
-        if (uid == base::nullopt) {
+        if (uid == std::nullopt) {
           PERFETTO_DLOG("Failed to parse game_mode_intervention.list uid.");
           return false;
         }
@@ -150,9 +150,9 @@
         break;
       }
       case 2: {
-        base::Optional<uint32_t> cur_mode =
+        std::optional<uint32_t> cur_mode =
             base::CStringToUInt32(string_splitter.cur_token());
-        if (cur_mode == base::nullopt) {
+        if (cur_mode == std::nullopt) {
           PERFETTO_DLOG(
               "Failed to parse game_mode_intervention.list cur_mode.");
           return false;
@@ -163,9 +163,9 @@
       case 3:
       case 5:
       case 7: {
-        base::Optional<uint32_t> game_mode =
+        std::optional<uint32_t> game_mode =
             base::CStringToUInt32(string_splitter.cur_token());
-        if (game_mode == base::nullopt) {
+        if (game_mode == std::nullopt) {
           PERFETTO_DLOG(
               "Failed to parse game_mode_intervention.list game_mode.");
           return false;
@@ -186,9 +186,9 @@
           char* key = value_splitter.cur_token();
           if (strcmp(key, "angle") == 0) {
             value_splitter.Next();
-            base::Optional<uint32_t> use_angle =
+            std::optional<uint32_t> use_angle =
                 base::CStringToUInt32(value_splitter.cur_token());
-            if (use_angle == base::nullopt) {
+            if (use_angle == std::nullopt) {
               PERFETTO_DLOG(
                   "Failed to parse game_mode_intervention.list use_angle.");
               return false;
@@ -196,9 +196,9 @@
             game_mode_info->set_use_angle(use_angle.value());
           } else if (strcmp(key, "scaling") == 0) {
             value_splitter.Next();
-            base::Optional<double> resolution_downscale =
+            std::optional<double> resolution_downscale =
                 base::CStringToDouble(value_splitter.cur_token());
-            if (resolution_downscale == base::nullopt) {
+            if (resolution_downscale == std::nullopt) {
               PERFETTO_DLOG(
                   "Failed to parse game_mode_intervention.list "
                   "resolution_downscale.");
@@ -208,9 +208,9 @@
                 static_cast<float>(resolution_downscale.value()));
           } else if (strcmp(key, "fps") == 0) {
             value_splitter.Next();
-            base::Optional<double> fps =
+            std::optional<double> fps =
                 base::CStringToDouble(value_splitter.cur_token());
-            if (fps == base::nullopt) {
+            if (fps == std::nullopt) {
               PERFETTO_DLOG("Failed to parse game_mode_intervention.list fps.");
               return false;
             }
diff --git a/src/traced/probes/android_log/android_log_data_source.cc b/src/traced/probes/android_log/android_log_data_source.cc
index 2d4d264..f53cda5 100644
--- a/src/traced/probes/android_log/android_log_data_source.cc
+++ b/src/traced/probes/android_log/android_log_data_source.cc
@@ -15,12 +15,12 @@
  */
 
 #include "src/traced/probes/android_log/android_log_data_source.h"
+#include <optional>
 
 #include "perfetto/base/logging.h"
 #include "perfetto/base/task_runner.h"
 #include "perfetto/base/time.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/ext/base/string_view.h"
diff --git a/src/traced/probes/android_system_property/android_system_property_data_source.cc b/src/traced/probes/android_system_property/android_system_property_data_source.cc
index b9ba2b8..2cf351e 100644
--- a/src/traced/probes/android_system_property/android_system_property_data_source.cc
+++ b/src/traced/probes/android_system_property/android_system_property_data_source.cc
@@ -15,11 +15,11 @@
  */
 
 #include "src/traced/probes/android_system_property/android_system_property_data_source.h"
+#include <optional>
 
 #include "perfetto/base/task_runner.h"
 #include "perfetto/base/time.h"
 #include "perfetto/ext/base/android_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/tracing/core/data_source_config.h"
 
@@ -100,7 +100,7 @@
   packet->set_timestamp(static_cast<uint64_t>(base::GetBootTimeNs().count()));
   auto* properties = packet->set_android_system_property();
   for (const auto& name : property_names_) {
-    const base::Optional<std::string> value = ReadProperty(name);
+    const std::optional<std::string> value = ReadProperty(name);
     if (value) {
       auto* property = properties->add_values();
       property->set_name(name);
@@ -118,20 +118,20 @@
 }
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-const base::Optional<std::string> AndroidSystemPropertyDataSource::ReadProperty(
+const std::optional<std::string> AndroidSystemPropertyDataSource::ReadProperty(
     const std::string& name) {
   std::string value = base::GetAndroidProp(name.c_str());
   if (value.empty()) {
     PERFETTO_LOG("Unable to read %s", name.c_str());
-    return base::nullopt;
+    return std::nullopt;
   }
-  return base::make_optional(value);
+  return std::make_optional(value);
 }
 #else
-const base::Optional<std::string> AndroidSystemPropertyDataSource::ReadProperty(
+const std::optional<std::string> AndroidSystemPropertyDataSource::ReadProperty(
     const std::string&) {
   PERFETTO_ELOG("Android System Properties only supported on Android.");
-  return base::nullopt;
+  return std::nullopt;
 }
 #endif
 
diff --git a/src/traced/probes/android_system_property/android_system_property_data_source.h b/src/traced/probes/android_system_property/android_system_property_data_source.h
index ec7db0e..04dd3e5 100644
--- a/src/traced/probes/android_system_property/android_system_property_data_source.h
+++ b/src/traced/probes/android_system_property/android_system_property_data_source.h
@@ -18,9 +18,9 @@
 #define SRC_TRACED_PROBES_ANDROID_SYSTEM_PROPERTY_ANDROID_SYSTEM_PROPERTY_DATA_SOURCE_H_
 
 #include <memory>
+#include <optional>
 #include <vector>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/weak_ptr.h"
 #include "perfetto/ext/tracing/core/trace_writer.h"
 #include "src/traced/probes/probes_data_source.h"
@@ -45,7 +45,7 @@
   void Flush(FlushRequestID, std::function<void()> callback) override;
 
   // Virtual for testing.
-  virtual const base::Optional<std::string> ReadProperty(
+  virtual const std::optional<std::string> ReadProperty(
       const std::string& name);
 
  private:
diff --git a/src/traced/probes/android_system_property/android_system_property_data_source_unittest.cc b/src/traced/probes/android_system_property/android_system_property_data_source_unittest.cc
index 89d89e6..0014e49 100644
--- a/src/traced/probes/android_system_property/android_system_property_data_source_unittest.cc
+++ b/src/traced/probes/android_system_property/android_system_property_data_source_unittest.cc
@@ -45,7 +45,7 @@
                                         std::move(writer)) {}
 
   MOCK_METHOD1(ReadProperty,
-               const base::Optional<std::string>(const std::string&));
+               const std::optional<std::string>(const std::string&));
 };
 
 class AndroidSystemPropertyDataSourceTest : public ::testing::Test {
@@ -79,9 +79,9 @@
   auto data_source = CreateAndroidSystemPropertyDataSource(BuildConfig(
       {"debug.tracing.screen_state", "debug.tracing.screen_brightness"}));
   EXPECT_CALL(*data_source, ReadProperty("debug.tracing.screen_state"))
-      .WillOnce(Return(base::make_optional("2")));
+      .WillOnce(Return(std::make_optional("2")));
   EXPECT_CALL(*data_source, ReadProperty("debug.tracing.screen_brightness"))
-      .WillOnce(Return(base::make_optional("0.123456")));
+      .WillOnce(Return(std::make_optional("0.123456")));
   data_source->Start();
 
   protos::gen::TracePacket packet = writer_raw_->GetOnlyTracePacket();
@@ -112,9 +112,9 @@
   auto data_source = CreateAndroidSystemPropertyDataSource(BuildConfig(
       {"debug.tracing.screen_state", "debug.tracing.screen_brightness"}));
   EXPECT_CALL(*data_source, ReadProperty("debug.tracing.screen_state"))
-      .WillOnce(Return(base::nullopt));
+      .WillOnce(Return(std::nullopt));
   EXPECT_CALL(*data_source, ReadProperty("debug.tracing.screen_brightness"))
-      .WillOnce(Return(base::nullopt));
+      .WillOnce(Return(std::nullopt));
   data_source->Start();
 
   protos::gen::TracePacket packet = writer_raw_->GetOnlyTracePacket();
diff --git a/src/traced/probes/ftrace/atrace_wrapper.cc b/src/traced/probes/ftrace/atrace_wrapper.cc
index 632c131..7254325 100644
--- a/src/traced/probes/ftrace/atrace_wrapper.cc
+++ b/src/traced/probes/ftrace/atrace_wrapper.cc
@@ -24,12 +24,12 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <optional>
 
 #include "perfetto/base/build_config.h"
 #include "perfetto/base/logging.h"
 #include "perfetto/base/time.h"
 #include "perfetto/ext/base/android_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/pipe.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/utils.h"
@@ -39,7 +39,7 @@
 namespace {
 
 RunAtraceFunction g_run_atrace_for_testing = nullptr;
-base::Optional<bool> g_is_old_atrace_for_testing{};
+std::optional<bool> g_is_old_atrace_for_testing{};
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
 // Args should include "atrace" for argv[0].
diff --git a/src/traced/probes/ftrace/compact_sched.cc b/src/traced/probes/ftrace/compact_sched.cc
index cd2d117..16cb848 100644
--- a/src/traced/probes/ftrace/compact_sched.cc
+++ b/src/traced/probes/ftrace/compact_sched.cc
@@ -17,8 +17,8 @@
 #include "src/traced/probes/ftrace/compact_sched.h"
 
 #include <stdint.h>
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "protos/perfetto/config/ftrace/ftrace_config.gen.h"
 #include "protos/perfetto/trace/ftrace/ftrace_event.pbzero.h"
 #include "protos/perfetto/trace/ftrace/sched.pbzero.h"
@@ -32,7 +32,7 @@
 // Pre-parse the format of sched_switch, checking if our simplifying
 // assumptions about possible widths/signedness hold, and record the subset
 // of the format that will be used during parsing.
-base::Optional<CompactSchedSwitchFormat> ValidateSchedSwitchFormat(
+std::optional<CompactSchedSwitchFormat> ValidateSchedSwitchFormat(
     const Event& event) {
   using protos::pbzero::SchedSwitchFtraceEvent;
 
@@ -85,15 +85,15 @@
 
   if (!prev_state_valid || !next_pid_valid || !next_prio_valid ||
       !next_comm_valid) {
-    return base::nullopt;
+    return std::nullopt;
   }
-  return base::make_optional(switch_format);
+  return std::make_optional(switch_format);
 }
 
 // Pre-parse the format of sched_waking, checking if our simplifying
 // assumptions about possible widths/signedness hold, and record the subset
 // of the format that will be used during parsing.
-base::Optional<CompactSchedWakingFormat> ValidateSchedWakingFormat(
+std::optional<CompactSchedWakingFormat> ValidateSchedWakingFormat(
     const Event& event) {
   using protos::pbzero::SchedWakingFtraceEvent;
 
@@ -143,9 +143,9 @@
   }
 
   if (!pid_valid || !target_cpu_valid || !prio_valid || !comm_valid) {
-    return base::nullopt;
+    return std::nullopt;
   }
-  return base::make_optional(waking_format);
+  return std::make_optional(waking_format);
 }
 
 }  // namespace
@@ -157,8 +157,8 @@
     const std::vector<Event>& events) {
   using protos::pbzero::FtraceEvent;
 
-  base::Optional<CompactSchedSwitchFormat> switch_format;
-  base::Optional<CompactSchedWakingFormat> waking_format;
+  std::optional<CompactSchedSwitchFormat> switch_format;
+  std::optional<CompactSchedWakingFormat> waking_format;
   for (const Event& event : events) {
     if (event.proto_field_id == FtraceEvent::kSchedSwitchFieldNumber) {
       switch_format = ValidateSchedSwitchFormat(event);
diff --git a/src/traced/probes/ftrace/cpu_reader.cc b/src/traced/probes/ftrace/cpu_reader.cc
index b4c1758..c38627c 100644
--- a/src/traced/probes/ftrace/cpu_reader.cc
+++ b/src/traced/probes/ftrace/cpu_reader.cc
@@ -21,12 +21,12 @@
 #include <signal.h>
 
 #include <algorithm>
+#include <optional>
 #include <utility>
 
 #include "perfetto/base/build_config.h"
 #include "perfetto/base/logging.h"
 #include "perfetto/ext/base/metatrace.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/utils.h"
@@ -267,7 +267,7 @@
       // prematurely.
       static constexpr size_t kRoughlyAPage = base::kPageSize - 512;
       const uint8_t* scratch_ptr = curr_page;
-      base::Optional<PageHeader> hdr =
+      std::optional<PageHeader> hdr =
           ParsePageHeader(&scratch_ptr, table_->page_header_size_len());
       PERFETTO_DCHECK(hdr && hdr->size > 0 && hdr->size <= base::kPageSize);
       if (!hdr.has_value()) {
@@ -426,7 +426,7 @@
     const uint8_t* curr_page = parsing_buf + (pages_parsed * base::kPageSize);
     const uint8_t* curr_page_end = curr_page + base::kPageSize;
     const uint8_t* parse_pos = curr_page;
-    base::Optional<PageHeader> page_header =
+    std::optional<PageHeader> page_header =
         ParsePageHeader(&parse_pos, table->page_header_size_len());
 
     if (!page_header.has_value() || page_header->size == 0 ||
@@ -477,7 +477,7 @@
 // flag (RB_MISSED_STORED).
 //
 // static
-base::Optional<CpuReader::PageHeader> CpuReader::ParsePageHeader(
+std::optional<CpuReader::PageHeader> CpuReader::ParsePageHeader(
     const uint8_t** ptr,
     uint16_t page_header_size_len) {
   // Mask for the data length portion of the |commit| field. Note that the
@@ -493,7 +493,7 @@
   PageHeader page_header;
   if (!CpuReader::ReadAndAdvance<uint64_t>(ptr, end_of_page,
                                            &page_header.timestamp))
-    return base::nullopt;
+    return std::nullopt;
 
   uint32_t size_and_flags;
 
@@ -501,7 +501,7 @@
   // number later.
   if (!CpuReader::ReadAndAdvance<uint32_t>(
           ptr, end_of_page, base::AssumeLittleEndian(&size_and_flags)))
-    return base::nullopt;
+    return std::nullopt;
 
   page_header.size = size_and_flags & kDataSizeMask;
   page_header.lost_events = bool(size_and_flags & kMissedEventsFlag);
@@ -513,7 +513,7 @@
   PERFETTO_DCHECK(page_header_size_len >= 4);
   *ptr += page_header_size_len - 4;
 
-  return base::make_optional(page_header);
+  return std::make_optional(page_header);
 }
 
 // A raw ftrace buffer page consists of a header followed by a sequence of
diff --git a/src/traced/probes/ftrace/cpu_reader.h b/src/traced/probes/ftrace/cpu_reader.h
index e0953d6..91e54ee 100644
--- a/src/traced/probes/ftrace/cpu_reader.h
+++ b/src/traced/probes/ftrace/cpu_reader.h
@@ -23,10 +23,10 @@
 #include <array>
 #include <atomic>
 #include <memory>
+#include <optional>
 #include <set>
 #include <thread>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/paged_memory.h"
 #include "perfetto/ext/base/pipe.h"
 #include "perfetto/ext/base/scoped_file.h"
@@ -174,7 +174,7 @@
   }
 
   // Returns a parsed representation of the given raw ftrace page's header.
-  static base::Optional<CpuReader::PageHeader> ParsePageHeader(
+  static std::optional<CpuReader::PageHeader> ParsePageHeader(
       const uint8_t** ptr,
       uint16_t page_header_size_len);
 
diff --git a/src/traced/probes/ftrace/cpu_reader_benchmark.cc b/src/traced/probes/ftrace/cpu_reader_benchmark.cc
index a029bc7..8b487b6 100644
--- a/src/traced/probes/ftrace/cpu_reader_benchmark.cc
+++ b/src/traced/probes/ftrace/cpu_reader_benchmark.cc
@@ -823,7 +823,7 @@
 
 void DoParse(const ExamplePage& test_case,
              const std::vector<GroupAndName>& enabled_events,
-             base::Optional<FtraceConfig::PrintFilter> print_filter,
+             std::optional<FtraceConfig::PrintFilter> print_filter,
              benchmark::State& state) {
   ScatteredStreamWriterNullDelegate delegate(base::kPageSize);
   ScatteredStreamWriter stream(&delegate);
@@ -835,7 +835,7 @@
   FtraceDataSourceConfig ds_config{EventFilter{},
                                    EventFilter{},
                                    DisabledCompactSchedConfigForTesting(),
-                                   base::nullopt,
+                                   std::nullopt,
                                    {},
                                    {},
                                    false /*symbolize_ksyms*/,
@@ -858,7 +858,7 @@
     std::unique_ptr<CompactSchedBuffer> compact_buffer(
         new CompactSchedBuffer());
     const uint8_t* parse_pos = page.get();
-    base::Optional<CpuReader::PageHeader> page_header =
+    std::optional<CpuReader::PageHeader> page_header =
         CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
     if (!page_header.has_value())
@@ -874,12 +874,12 @@
 
 void BM_ParsePageFullOfSchedSwitch(benchmark::State& state) {
   DoParse(g_full_page_sched_switch, {GroupAndName("sched", "sched_switch")},
-          base::nullopt, state);
+          std::nullopt, state);
 }
 BENCHMARK(BM_ParsePageFullOfSchedSwitch);
 
 void BM_ParsePageFullOfPrint(benchmark::State& state) {
-  DoParse(g_full_page_print, {GroupAndName("ftrace", "print")}, base::nullopt,
+  DoParse(g_full_page_print, {GroupAndName("ftrace", "print")}, std::nullopt,
           state);
 }
 BENCHMARK(BM_ParsePageFullOfPrint);
@@ -898,7 +898,7 @@
 
 void BM_ParsePageFullOfAtracePrint(benchmark::State& state) {
   DoParse(g_full_page_atrace_print, {GroupAndName("ftrace", "print")},
-          base::nullopt, state);
+          std::nullopt, state);
 }
 BENCHMARK(BM_ParsePageFullOfAtracePrint);
 
diff --git a/src/traced/probes/ftrace/cpu_reader_fuzzer.cc b/src/traced/probes/ftrace/cpu_reader_fuzzer.cc
index 76908c9..f9dd522 100644
--- a/src/traced/probes/ftrace/cpu_reader_fuzzer.cc
+++ b/src/traced/probes/ftrace/cpu_reader_fuzzer.cc
@@ -57,7 +57,7 @@
   FtraceDataSourceConfig ds_config{EventFilter{},
                                    EventFilter{},
                                    DisabledCompactSchedConfigForTesting(),
-                                   base::nullopt,
+                                   std::nullopt,
                                    {},
                                    {},
                                    /*symbolize_ksyms=*/false,
diff --git a/src/traced/probes/ftrace/cpu_reader_unittest.cc b/src/traced/probes/ftrace/cpu_reader_unittest.cc
index 2466109..ba77921 100644
--- a/src/traced/probes/ftrace/cpu_reader_unittest.cc
+++ b/src/traced/probes/ftrace/cpu_reader_unittest.cc
@@ -68,7 +68,7 @@
   return FtraceDataSourceConfig{EventFilter{},
                                 EventFilter{},
                                 DisabledCompactSchedConfigForTesting(),
-                                base::nullopt,
+                                std::nullopt,
                                 {},
                                 {},
                                 false /*symbolize_ksyms*/,
@@ -393,7 +393,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -521,7 +521,7 @@
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
 
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -569,7 +569,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -617,7 +617,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -653,7 +653,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   ASSERT_TRUE(page_header.has_value());
@@ -718,7 +718,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -767,7 +767,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -907,7 +907,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -948,7 +948,7 @@
   FtraceDataSourceConfig ds_config{EventFilter{},
                                    EventFilter{},
                                    EnabledCompactSchedConfigForTesting(),
-                                   base::nullopt,
+                                   std::nullopt,
                                    {},
                                    {},
                                    false /* symbolize_ksyms*/,
@@ -960,7 +960,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -1705,7 +1705,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -2193,7 +2193,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -2281,7 +2281,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
   ASSERT_TRUE(page_header.has_value());
 
@@ -2725,7 +2725,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -2834,7 +2834,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
@@ -3140,7 +3140,7 @@
   FtraceMetadata metadata{};
   std::unique_ptr<CompactSchedBuffer> compact_buffer(new CompactSchedBuffer());
   const uint8_t* parse_pos = page.get();
-  base::Optional<CpuReader::PageHeader> page_header =
+  std::optional<CpuReader::PageHeader> page_header =
       CpuReader::ParsePageHeader(&parse_pos, table->page_header_size_len());
 
   const uint8_t* page_end = page.get() + base::kPageSize;
diff --git a/src/traced/probes/ftrace/ftrace_config_muxer.cc b/src/traced/probes/ftrace/ftrace_config_muxer.cc
index 61a26dd..0be1842 100644
--- a/src/traced/probes/ftrace/ftrace_config_muxer.cc
+++ b/src/traced/probes/ftrace/ftrace_config_muxer.cc
@@ -523,7 +523,7 @@
   }
 
   for (const std::string& syscall : request.syscall_events()) {
-    base::Optional<size_t> id = syscalls_.GetByName(syscall);
+    std::optional<size_t> id = syscalls_.GetByName(syscall);
     if (!id.has_value()) {
       PERFETTO_ELOG("Can't enable %s, syscall not known", syscall.c_str());
       continue;
@@ -744,7 +744,7 @@
   auto compact_sched =
       CreateCompactSchedConfig(request, table_->compact_sched_format());
 
-  base::Optional<FtracePrintFilterConfig> ftrace_print_filter;
+  std::optional<FtracePrintFilterConfig> ftrace_print_filter;
   if (request.has_print_filter()) {
     ftrace_print_filter =
         FtracePrintFilterConfig::Create(request.print_filter(), table_);
diff --git a/src/traced/probes/ftrace/ftrace_config_muxer.h b/src/traced/probes/ftrace/ftrace_config_muxer.h
index 49a5989..67176b2 100644
--- a/src/traced/probes/ftrace/ftrace_config_muxer.h
+++ b/src/traced/probes/ftrace/ftrace_config_muxer.h
@@ -18,9 +18,9 @@
 #define SRC_TRACED_PROBES_FTRACE_FTRACE_CONFIG_MUXER_H_
 
 #include <map>
+#include <optional>
 #include <set>
 
-#include "perfetto/ext/base/optional.h"
 #include "src/kernel_utils/syscall_table.h"
 #include "src/traced/probes/ftrace/compact_sched.h"
 #include "src/traced/probes/ftrace/ftrace_config_utils.h"
@@ -44,7 +44,7 @@
   FtraceDataSourceConfig(EventFilter _event_filter,
                          EventFilter _syscall_filter,
                          CompactSchedConfig _compact_sched,
-                         base::Optional<FtracePrintFilterConfig> _print_filter,
+                         std::optional<FtracePrintFilterConfig> _print_filter,
                          std::vector<std::string> _atrace_apps,
                          std::vector<std::string> _atrace_categories,
                          bool _symbolize_ksyms,
@@ -72,7 +72,7 @@
 
   // Optional configuration that's used to filter "ftrace/print" events based on
   // the content of their "buf" field.
-  base::Optional<FtracePrintFilterConfig> print_filter;
+  std::optional<FtracePrintFilterConfig> print_filter;
 
   // Used only in Android for ATRACE_EVENT/os.Trace() userspace annotations.
   std::vector<std::string> atrace_apps;
diff --git a/src/traced/probes/ftrace/ftrace_controller.cc b/src/traced/probes/ftrace/ftrace_controller.cc
index 49d4080..907e772 100644
--- a/src/traced/probes/ftrace/ftrace_controller.cc
+++ b/src/traced/probes/ftrace/ftrace_controller.cc
@@ -96,13 +96,13 @@
   return !!fd;
 }
 
-base::Optional<int64_t> ReadFtraceNowTs(const base::ScopedFile& cpu_stats_fd) {
+std::optional<int64_t> ReadFtraceNowTs(const base::ScopedFile& cpu_stats_fd) {
   PERFETTO_CHECK(cpu_stats_fd);
 
   char buf[512];
   ssize_t res = PERFETTO_EINTR(pread(*cpu_stats_fd, buf, sizeof(buf) - 1, 0));
   if (res <= 0)
-    return base::nullopt;
+    return std::nullopt;
   buf[res] = '\0';
 
   FtraceCpuStats stats{};
@@ -635,7 +635,7 @@
 // TODO(rsavitski): dedupe with FtraceController::Create.
 std::unique_ptr<FtraceController::FtraceInstanceState>
 FtraceController::CreateSecondaryInstance(const std::string& instance_name) {
-  base::Optional<std::string> instance_path = AbsolutePathForInstance(
+  std::optional<std::string> instance_path = AbsolutePathForInstance(
       primary_.ftrace_procfs->GetRootPath(), instance_name);
   if (!instance_path.has_value()) {
     PERFETTO_ELOG("Invalid ftrace instance name: \"%s\"",
@@ -675,12 +675,12 @@
 // to be careful to distinguish the tracefs mount point from the default
 // instance path.
 // static
-base::Optional<std::string> FtraceController::AbsolutePathForInstance(
+std::optional<std::string> FtraceController::AbsolutePathForInstance(
     const std::string& tracefs_root,
     const std::string& raw_cfg_name) {
   if (base::Contains(raw_cfg_name, '/') ||
       base::StartsWith(raw_cfg_name, "..")) {
-    return base::nullopt;
+    return std::nullopt;
   }
 
   // ARM64 pKVM hypervisor tracing emulates an instance, but is not under
@@ -690,7 +690,7 @@
     PERFETTO_LOG(
         "Config specified reserved \"hyp\" instance name, using %s for events.",
         hyp_path.c_str());
-    return base::make_optional(hyp_path);
+    return std::make_optional(hyp_path);
   }
 
   return tracefs_root + "instances/" + raw_cfg_name + "/";
diff --git a/src/traced/probes/ftrace/ftrace_controller.h b/src/traced/probes/ftrace/ftrace_controller.h
index 9318f2a..e4f3848 100644
--- a/src/traced/probes/ftrace/ftrace_controller.h
+++ b/src/traced/probes/ftrace/ftrace_controller.h
@@ -88,7 +88,7 @@
   }
 
   // public for testing
-  static base::Optional<std::string> AbsolutePathForInstance(
+  static std::optional<std::string> AbsolutePathForInstance(
       const std::string& tracefs_root,
       const std::string& raw_cfg_name);
 
diff --git a/src/traced/probes/ftrace/ftrace_controller_unittest.cc b/src/traced/probes/ftrace/ftrace_controller_unittest.cc
index 0d41004..02bb3cf 100644
--- a/src/traced/probes/ftrace/ftrace_controller_unittest.cc
+++ b/src/traced/probes/ftrace/ftrace_controller_unittest.cc
@@ -756,7 +756,7 @@
 }
 
 TEST(FtraceControllerTest, TracefsInstanceFilepaths) {
-  base::Optional<std::string> path;
+  std::optional<std::string> path;
   path = FtraceController::AbsolutePathForInstance("/root/", "test");
   EXPECT_EQ(*path, "/root/instances/test/");
 
diff --git a/src/traced/probes/ftrace/ftrace_print_filter.cc b/src/traced/probes/ftrace/ftrace_print_filter.cc
index 5080fca..316a017 100644
--- a/src/traced/probes/ftrace/ftrace_print_filter.cc
+++ b/src/traced/probes/ftrace/ftrace_print_filter.cc
@@ -108,12 +108,12 @@
 }
 
 // static
-base::Optional<FtracePrintFilterConfig> FtracePrintFilterConfig::Create(
+std::optional<FtracePrintFilterConfig> FtracePrintFilterConfig::Create(
     const protos::gen::FtraceConfig::PrintFilter& config,
     ProtoTranslationTable* table) {
   const Event* print_event = table->GetEvent(GroupAndName("ftrace", "print"));
   if (!print_event) {
-    return base::nullopt;
+    return std::nullopt;
   }
   const Field* buf_field = nullptr;
   for (const Field& field : print_event->fields) {
@@ -123,11 +123,11 @@
     }
   }
   if (!buf_field) {
-    return base::nullopt;
+    return std::nullopt;
   }
 
   if (buf_field->strategy != kCStringToString) {
-    return base::nullopt;
+    return std::nullopt;
   }
   FtracePrintFilterConfig ret{FtracePrintFilter{config}};
   ret.event_id_ = print_event->ftrace_event_id;
diff --git a/src/traced/probes/ftrace/ftrace_print_filter.h b/src/traced/probes/ftrace/ftrace_print_filter.h
index 707bb3e..419bcbf 100644
--- a/src/traced/probes/ftrace/ftrace_print_filter.h
+++ b/src/traced/probes/ftrace/ftrace_print_filter.h
@@ -17,10 +17,10 @@
 #ifndef SRC_TRACED_PROBES_FTRACE_FTRACE_PRINT_FILTER_H_
 #define SRC_TRACED_PROBES_FTRACE_FTRACE_PRINT_FILTER_H_
 
+#include <optional>
 #include <string>
 #include <vector>
 
-#include "perfetto/ext/base/optional.h"
 #include "src/traced/probes/ftrace/proto_translation_table.h"
 
 namespace perfetto {
@@ -62,7 +62,7 @@
 
 class FtracePrintFilterConfig {
  public:
-  static base::Optional<FtracePrintFilterConfig> Create(
+  static std::optional<FtracePrintFilterConfig> Create(
       const protos::gen::FtraceConfig_PrintFilter&,
       ProtoTranslationTable* table);
 
diff --git a/src/traced/probes/ftrace/ftrace_procfs.cc b/src/traced/probes/ftrace/ftrace_procfs.cc
index 7cf3b07..6112487 100644
--- a/src/traced/probes/ftrace/ftrace_procfs.cc
+++ b/src/traced/probes/ftrace/ftrace_procfs.cc
@@ -590,7 +590,7 @@
   if (str.size() && str[str.size() - 1] == '\n')
     str.resize(str.size() - 1);
 
-  base::Optional<uint32_t> id = base::StringToUInt32(str);
+  std::optional<uint32_t> id = base::StringToUInt32(str);
   if (!id)
     return 0;
   return *id;
diff --git a/src/traced/probes/ftrace/printk_formats_parser.cc b/src/traced/probes/ftrace/printk_formats_parser.cc
index 9a36dab..99dc856 100644
--- a/src/traced/probes/ftrace/printk_formats_parser.cc
+++ b/src/traced/probes/ftrace/printk_formats_parser.cc
@@ -19,10 +19,10 @@
 #include <stdio.h>
 
 #include <cinttypes>
+#include <optional>
 
 #include "perfetto/base/logging.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/ext/base/string_utils.h"
 
@@ -52,7 +52,7 @@
     if (name.empty())
       continue;
 
-    base::Optional<uint64_t> address = base::StringToUInt64(raw_address, 16);
+    std::optional<uint64_t> address = base::StringToUInt64(raw_address, 16);
     if (address && address.value() != 0)
       mapping.insert(address.value(), name);
   }
diff --git a/src/traced/probes/initial_display_state/initial_display_state_data_source.cc b/src/traced/probes/initial_display_state/initial_display_state_data_source.cc
index d08cfd4..f7d3e58 100644
--- a/src/traced/probes/initial_display_state/initial_display_state_data_source.cc
+++ b/src/traced/probes/initial_display_state/initial_display_state_data_source.cc
@@ -15,11 +15,11 @@
  */
 
 #include "src/traced/probes/initial_display_state/initial_display_state_data_source.h"
+#include <optional>
 
 #include "perfetto/base/task_runner.h"
 #include "perfetto/base/time.h"
 #include "perfetto/ext/base/android_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/tracing/core/data_source_config.h"
 
@@ -87,15 +87,15 @@
 void InitialDisplayStateDataSource::WriteState() {
   auto packet = writer_->NewTracePacket();
   packet->set_timestamp(static_cast<uint64_t>(base::GetBootTimeNs().count()));
-  const base::Optional<std::string> screen_state_str =
+  const std::optional<std::string> screen_state_str =
       ReadProperty("debug.tracing.screen_state");
-  const base::Optional<std::string> screen_brightness_str =
+  const std::optional<std::string> screen_brightness_str =
       ReadProperty("debug.tracing.screen_brightness");
-  const base::Optional<int> screen_state =
-      screen_state_str ? base::StringToInt32(*screen_state_str) : base::nullopt;
-  const base::Optional<double> screen_brightness =
+  const std::optional<int> screen_state =
+      screen_state_str ? base::StringToInt32(*screen_state_str) : std::nullopt;
+  const std::optional<double> screen_brightness =
       screen_brightness_str ? base::StringToDouble(*screen_brightness_str)
-                            : base::nullopt;
+                            : std::nullopt;
   if (screen_state || screen_brightness) {
     auto* state = packet->set_initial_display_state();
     if (screen_state) {
@@ -116,20 +116,20 @@
 }
 
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
-const base::Optional<std::string> InitialDisplayStateDataSource::ReadProperty(
+const std::optional<std::string> InitialDisplayStateDataSource::ReadProperty(
     const std::string name) {
   std::string value = base::GetAndroidProp(name.c_str());
   if (value.empty()) {
     PERFETTO_ELOG("Unable to read %s", name.c_str());
-    return base::nullopt;
+    return std::nullopt;
   }
-  return base::make_optional(value);
+  return std::make_optional(value);
 }
 #else
-const base::Optional<std::string> InitialDisplayStateDataSource::ReadProperty(
+const std::optional<std::string> InitialDisplayStateDataSource::ReadProperty(
     const std::string name __attribute__((unused))) {
   PERFETTO_ELOG("Initial display state only supported on Android.");
-  return base::nullopt;
+  return std::nullopt;
 }
 #endif
 
diff --git a/src/traced/probes/initial_display_state/initial_display_state_data_source.h b/src/traced/probes/initial_display_state/initial_display_state_data_source.h
index b235c75..acb8789 100644
--- a/src/traced/probes/initial_display_state/initial_display_state_data_source.h
+++ b/src/traced/probes/initial_display_state/initial_display_state_data_source.h
@@ -18,8 +18,8 @@
 #define SRC_TRACED_PROBES_INITIAL_DISPLAY_STATE_INITIAL_DISPLAY_STATE_DATA_SOURCE_H_
 
 #include <memory>
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/weak_ptr.h"
 #include "perfetto/ext/tracing/core/trace_writer.h"
 #include "src/traced/probes/probes_data_source.h"
@@ -44,8 +44,7 @@
   void Flush(FlushRequestID, std::function<void()> callback) override;
 
   // Virtual for testing.
-  virtual const base::Optional<std::string> ReadProperty(
-      const std::string name);
+  virtual const std::optional<std::string> ReadProperty(const std::string name);
 
  private:
   void Tick();
diff --git a/src/traced/probes/initial_display_state/initial_display_state_data_source_unittest.cc b/src/traced/probes/initial_display_state/initial_display_state_data_source_unittest.cc
index f851ae6..6cb5f86 100644
--- a/src/traced/probes/initial_display_state/initial_display_state_data_source_unittest.cc
+++ b/src/traced/probes/initial_display_state/initial_display_state_data_source_unittest.cc
@@ -41,7 +41,7 @@
                                       std::move(writer)) {}
 
   MOCK_METHOD1(ReadProperty,
-               const base::Optional<std::string>(const std::string));
+               const std::optional<std::string>(const std::string));
 };
 
 class InitialDisplayStateDataSourceTest : public ::testing::Test {
@@ -65,9 +65,9 @@
   ASSERT_TRUE(true);
   auto data_source = GetInitialDisplayStateDataSource(DataSourceConfig());
   EXPECT_CALL(*data_source, ReadProperty("debug.tracing.screen_state"))
-      .WillOnce(Return(base::make_optional("2")));
+      .WillOnce(Return(std::make_optional("2")));
   EXPECT_CALL(*data_source, ReadProperty("debug.tracing.screen_brightness"))
-      .WillOnce(Return(base::make_optional("0.123456")));
+      .WillOnce(Return(std::make_optional("0.123456")));
   data_source->Start();
 
   protos::gen::TracePacket packet = writer_raw_->GetOnlyTracePacket();
@@ -81,9 +81,9 @@
   ASSERT_TRUE(true);
   auto data_source = GetInitialDisplayStateDataSource(DataSourceConfig());
   EXPECT_CALL(*data_source, ReadProperty("debug.tracing.screen_state"))
-      .WillOnce(Return(base::make_optional("2")));
+      .WillOnce(Return(std::make_optional("2")));
   EXPECT_CALL(*data_source, ReadProperty("debug.tracing.screen_brightness"))
-      .WillOnce(Return(base::make_optional("gotta wear shades")));
+      .WillOnce(Return(std::make_optional("gotta wear shades")));
   data_source->Start();
 
   protos::gen::TracePacket packet = writer_raw_->GetOnlyTracePacket();
@@ -97,9 +97,9 @@
   ASSERT_TRUE(true);
   auto data_source = GetInitialDisplayStateDataSource(DataSourceConfig());
   EXPECT_CALL(*data_source, ReadProperty("debug.tracing.screen_state"))
-      .WillOnce(Return(base::nullopt));
+      .WillOnce(Return(std::nullopt));
   EXPECT_CALL(*data_source, ReadProperty("debug.tracing.screen_brightness"))
-      .WillOnce(Return(base::nullopt));
+      .WillOnce(Return(std::nullopt));
   data_source->Start();
 
   protos::gen::TracePacket packet = writer_raw_->GetOnlyTracePacket();
diff --git a/src/traced/probes/power/android_power_data_source.cc b/src/traced/probes/power/android_power_data_source.cc
index 3f2866e..c67a8b2 100644
--- a/src/traced/probes/power/android_power_data_source.cc
+++ b/src/traced/probes/power/android_power_data_source.cc
@@ -16,12 +16,12 @@
 
 #include "src/traced/probes/power/android_power_data_source.h"
 
+#include <optional>
 #include <vector>
 
 #include "perfetto/base/logging.h"
 #include "perfetto/base/task_runner.h"
 #include "perfetto/base/time.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/tracing/core/trace_packet.h"
 #include "perfetto/ext/tracing/core/trace_writer.h"
@@ -70,13 +70,13 @@
   PERFETTO_LAZY_LOAD(android_internal::GetPowerEntityStateResidency,
                      get_power_entity_state_residency_);
 
-  base::Optional<int64_t> GetCounter(android_internal::BatteryCounter counter) {
+  std::optional<int64_t> GetCounter(android_internal::BatteryCounter counter) {
     if (!get_battery_counter_)
-      return base::nullopt;
+      return std::nullopt;
     int64_t value = 0;
     if (get_battery_counter_(counter, &value))
-      return base::make_optional(value);
-    return base::nullopt;
+      return std::make_optional(value);
+    return std::nullopt;
   }
 
   std::vector<android_internal::RailDescriptor> GetRailDescriptors() {
diff --git a/src/traced/probes/power/linux_power_sysfs_data_source.cc b/src/traced/probes/power/linux_power_sysfs_data_source.cc
index 9d4365b..ceeeec7 100644
--- a/src/traced/probes/power/linux_power_sysfs_data_source.cc
+++ b/src/traced/probes/power/linux_power_sysfs_data_source.cc
@@ -18,12 +18,12 @@
 
 #include <dirent.h>
 #include <sys/types.h>
+#include <optional>
 
 #include "perfetto/base/logging.h"
 #include "perfetto/base/task_runner.h"
 #include "perfetto/base/time.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/tracing/core/trace_packet.h"
@@ -38,10 +38,10 @@
 namespace {
 constexpr uint32_t kDefaultPollIntervalMs = 1000;
 
-base::Optional<int64_t> ReadFileAsInt64(std::string path) {
+std::optional<int64_t> ReadFileAsInt64(std::string path) {
   std::string buf;
   if (!base::ReadFile(path, &buf))
-    return base::nullopt;
+    return std::nullopt;
   return base::StringToInt64(base::StripSuffix(buf, "\n"));
 }
 }  // namespace
@@ -76,7 +76,7 @@
   return sysfs_battery_subdirs_.size();
 }
 
-base::Optional<int64_t>
+std::optional<int64_t>
 LinuxPowerSysfsDataSource::BatteryInfo::GetChargeCounterUah(
     size_t battery_idx) {
   PERFETTO_CHECK(battery_idx < sysfs_battery_subdirs_.size());
@@ -84,7 +84,7 @@
                          sysfs_battery_subdirs_[battery_idx] + "/charge_now");
 }
 
-base::Optional<int64_t>
+std::optional<int64_t>
 LinuxPowerSysfsDataSource::BatteryInfo::GetEnergyCounterUah(
     size_t battery_idx) {
   PERFETTO_CHECK(battery_idx < sysfs_battery_subdirs_.size());
@@ -92,28 +92,28 @@
                          sysfs_battery_subdirs_[battery_idx] + "/energy_now");
 }
 
-base::Optional<int64_t> LinuxPowerSysfsDataSource::BatteryInfo::GetVoltageUv(
+std::optional<int64_t> LinuxPowerSysfsDataSource::BatteryInfo::GetVoltageUv(
     size_t battery_idx) {
   PERFETTO_CHECK(battery_idx < sysfs_battery_subdirs_.size());
   return ReadFileAsInt64(power_supply_dir_path_ + "/" +
                          sysfs_battery_subdirs_[battery_idx] + "/voltage_now");
 }
 
-base::Optional<int64_t>
+std::optional<int64_t>
 LinuxPowerSysfsDataSource::BatteryInfo::GetCapacityPercent(size_t battery_idx) {
   PERFETTO_CHECK(battery_idx < sysfs_battery_subdirs_.size());
   return ReadFileAsInt64(power_supply_dir_path_ + "/" +
                          sysfs_battery_subdirs_[battery_idx] + "/capacity");
 }
 
-base::Optional<int64_t> LinuxPowerSysfsDataSource::BatteryInfo::GetCurrentNowUa(
+std::optional<int64_t> LinuxPowerSysfsDataSource::BatteryInfo::GetCurrentNowUa(
     size_t battery_idx) {
   PERFETTO_CHECK(battery_idx < sysfs_battery_subdirs_.size());
   return ReadFileAsInt64(power_supply_dir_path_ + "/" +
                          sysfs_battery_subdirs_[battery_idx] + "/current_now");
 }
 
-base::Optional<int64_t>
+std::optional<int64_t>
 LinuxPowerSysfsDataSource::BatteryInfo::GetAverageCurrentUa(
     size_t battery_idx) {
   PERFETTO_CHECK(battery_idx < sysfs_battery_subdirs_.size());
diff --git a/src/traced/probes/power/linux_power_sysfs_data_source.h b/src/traced/probes/power/linux_power_sysfs_data_source.h
index 058ccd6..7916534 100644
--- a/src/traced/probes/power/linux_power_sysfs_data_source.h
+++ b/src/traced/probes/power/linux_power_sysfs_data_source.h
@@ -17,7 +17,8 @@
 #ifndef SRC_TRACED_PROBES_POWER_LINUX_POWER_SYSFS_DATA_SOURCE_H_
 #define SRC_TRACED_PROBES_POWER_LINUX_POWER_SYSFS_DATA_SOURCE_H_
 
-#include "perfetto/ext/base/optional.h"
+#include <optional>
+
 #include "perfetto/ext/base/weak_ptr.h"
 #include "perfetto/tracing/core/data_source_config.h"
 #include "src/traced/probes/probes_data_source.h"
@@ -39,22 +40,22 @@
     ~BatteryInfo();
 
     // The current coloumb counter value in µAh.
-    base::Optional<int64_t> GetChargeCounterUah(size_t battery_idx);
+    std::optional<int64_t> GetChargeCounterUah(size_t battery_idx);
 
     // The current energy counter in µWh.
-    base::Optional<int64_t> GetEnergyCounterUah(size_t battery_idx);
+    std::optional<int64_t> GetEnergyCounterUah(size_t battery_idx);
 
     // The voltage in µV.
-    base::Optional<int64_t> GetVoltageUv(size_t battery_idx);
+    std::optional<int64_t> GetVoltageUv(size_t battery_idx);
 
     // The battery capacity in percent.
-    base::Optional<int64_t> GetCapacityPercent(size_t battery_idx);
+    std::optional<int64_t> GetCapacityPercent(size_t battery_idx);
 
     // The current reading of the battery in µA.
-    base::Optional<int64_t> GetCurrentNowUa(size_t battery_idx);
+    std::optional<int64_t> GetCurrentNowUa(size_t battery_idx);
 
     // The smoothed current reading of the battery in µA.
-    base::Optional<int64_t> GetAverageCurrentUa(size_t battery_idx);
+    std::optional<int64_t> GetAverageCurrentUa(size_t battery_idx);
 
     // Name of the battery.
     std::string GetBatteryName(size_t battery_idx);
diff --git a/src/traced/probes/power/linux_power_sysfs_data_source_unittest.cc b/src/traced/probes/power/linux_power_sysfs_data_source_unittest.cc
index 2c1c8aa..442d767 100644
--- a/src/traced/probes/power/linux_power_sysfs_data_source_unittest.cc
+++ b/src/traced/probes/power/linux_power_sysfs_data_source_unittest.cc
@@ -59,9 +59,9 @@
 
   EXPECT_EQ(battery_info_->num_batteries(), 1u);
   EXPECT_EQ(*battery_info_->GetCapacityPercent(0), 88);
-  EXPECT_EQ(battery_info_->GetCurrentNowUa(0), base::nullopt);
-  EXPECT_EQ(battery_info_->GetAverageCurrentUa(0), base::nullopt);
-  EXPECT_EQ(battery_info_->GetChargeCounterUah(0), base::nullopt);
+  EXPECT_EQ(battery_info_->GetCurrentNowUa(0), std::nullopt);
+  EXPECT_EQ(battery_info_->GetAverageCurrentUa(0), std::nullopt);
+  EXPECT_EQ(battery_info_->GetChargeCounterUah(0), std::nullopt);
 }
 
 TEST(LinuxPowerSysfsDataSourceTest, MultipleBatteries) {
@@ -92,11 +92,11 @@
   size_t second_battery_idx = main_battery_idx == 0 ? 1 : 0;
 
   EXPECT_EQ(*battery_info_->GetCapacityPercent(second_battery_idx), 88);
-  EXPECT_EQ(battery_info_->GetCurrentNowUa(second_battery_idx), base::nullopt);
+  EXPECT_EQ(battery_info_->GetCurrentNowUa(second_battery_idx), std::nullopt);
   EXPECT_EQ(battery_info_->GetAverageCurrentUa(second_battery_idx),
-            base::nullopt);
+            std::nullopt);
   EXPECT_EQ(battery_info_->GetChargeCounterUah(second_battery_idx),
-            base::nullopt);
+            std::nullopt);
 
   EXPECT_EQ(*battery_info_->GetCapacityPercent(main_battery_idx), 95);
   EXPECT_EQ(*battery_info_->GetCurrentNowUa(main_battery_idx), 245000);
diff --git a/src/traced/probes/statsd_client/statsd_binder_data_source.cc b/src/traced/probes/statsd_client/statsd_binder_data_source.cc
index b05451b..9b79fca 100644
--- a/src/traced/probes/statsd_client/statsd_binder_data_source.cc
+++ b/src/traced/probes/statsd_client/statsd_binder_data_source.cc
@@ -20,10 +20,10 @@
 
 #include <map>
 #include <mutex>
+#include <optional>
 
 #include "perfetto/base/time.h"
 #include "perfetto/ext/base/no_destructor.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/protozero/scattered_heap_buffer.h"
 #include "perfetto/tracing/core/data_source_config.h"
diff --git a/src/traced/probes/sys_stats/sys_stats_data_source.cc b/src/traced/probes/sys_stats/sys_stats_data_source.cc
index 9543d7c..e5c02a9 100644
--- a/src/traced/probes/sys_stats/sys_stats_data_source.cc
+++ b/src/traced/probes/sys_stats/sys_stats_data_source.cc
@@ -253,7 +253,7 @@
       if (index == 2) {  // index for device name (string)
         disk_stat->set_device_name(words.cur_token());
       } else if (index >= 5) {  // integer values from index 5
-        base::Optional<uint64_t> value_address =
+        std::optional<uint64_t> value_address =
             base::CStringToUInt64(words.cur_token());
         uint64_t value = value_address ? *value_address : 0;
 
diff --git a/src/tracing/console_interceptor.cc b/src/tracing/console_interceptor.cc
index bb700f1..2c3221f 100644
--- a/src/tracing/console_interceptor.cc
+++ b/src/tracing/console_interceptor.cc
@@ -20,11 +20,11 @@
 
 #include <algorithm>
 #include <cmath>
+#include <optional>
 #include <tuple>
 
 #include "perfetto/ext/base/file_utils.h"
 #include "perfetto/ext/base/hash.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "perfetto/ext/base/utils.h"
@@ -129,7 +129,7 @@
   using SelfHandle = LockedHandle<ConsoleInterceptor>;
 
   InterceptorContext& context_;
-  base::Optional<SelfHandle> locked_self_;
+  std::optional<SelfHandle> locked_self_;
 };
 
 ConsoleInterceptor::~ConsoleInterceptor() = default;
@@ -157,7 +157,7 @@
   if (locked_self_.has_value())
     return &locked_self_.value()->session_state_;
   locked_self_ =
-      base::make_optional<SelfHandle>(context_.GetInterceptorLocked());
+      std::make_optional<SelfHandle>(context_.GetInterceptorLocked());
   return &locked_self_.value()->session_state_;
 }
 
diff --git a/src/tracing/core/tracing_service_impl.cc b/src/tracing/core/tracing_service_impl.cc
index 0ee3122..8299500 100644
--- a/src/tracing/core/tracing_service_impl.cc
+++ b/src/tracing/core/tracing_service_impl.cc
@@ -1902,7 +1902,7 @@
       // reset to 0 by the service when the chunk was freed).
 
       WriterID writer_id = chunk.writer_id();
-      base::Optional<BufferID> target_buffer_id =
+      std::optional<BufferID> target_buffer_id =
           producer->buffer_id_for_writer(writer_id);
 
       // We can only scrape this chunk if we know which log buffer to copy it
@@ -2833,7 +2833,7 @@
 
   // If the writer was registered by the producer, it should only write into the
   // buffer it was registered with.
-  base::Optional<BufferID> associated_buffer =
+  std::optional<BufferID> associated_buffer =
       producer->buffer_id_for_writer(writer_id);
   if (associated_buffer && *associated_buffer != buffer_id) {
     PERFETTO_ELOG("Writer %" PRIu16 " of producer %" PRIu16
@@ -3334,7 +3334,7 @@
   }
 
   std::string sdk_str_value = base::GetAndroidProp("ro.build.version.sdk");
-  base::Optional<uint64_t> sdk_value = base::StringToUInt64(sdk_str_value);
+  std::optional<uint64_t> sdk_value = base::StringToUInt64(sdk_str_value);
   if (sdk_value.has_value()) {
     info->set_android_sdk_version(*sdk_value);
   } else {
diff --git a/src/tracing/core/tracing_service_impl.h b/src/tracing/core/tracing_service_impl.h
index 02e5639..7cefb9b 100644
--- a/src/tracing/core/tracing_service_impl.h
+++ b/src/tracing/core/tracing_service_impl.h
@@ -22,6 +22,7 @@
 #include <map>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <random>
 #include <set>
 #include <utility>
@@ -31,7 +32,6 @@
 #include "perfetto/base/status.h"
 #include "perfetto/base/time.h"
 #include "perfetto/ext/base/circular_queue.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/periodic_task.h"
 #include "perfetto/ext/base/uuid.h"
 #include "perfetto/ext/base/weak_ptr.h"
@@ -143,11 +143,11 @@
       return allowed_target_buffers_.count(buffer_id);
     }
 
-    base::Optional<BufferID> buffer_id_for_writer(WriterID writer_id) const {
+    std::optional<BufferID> buffer_id_for_writer(WriterID writer_id) const {
       const auto it = writers_.find(writer_id);
       if (it != writers_.end())
         return it->second;
-      return base::nullopt;
+      return std::nullopt;
     }
 
     uid_t uid() const { return uid_; }
diff --git a/src/tracing/internal/tracing_muxer_impl_integrationtest.cc b/src/tracing/internal/tracing_muxer_impl_integrationtest.cc
index e1cfbfd..5711d73 100644
--- a/src/tracing/internal/tracing_muxer_impl_integrationtest.cc
+++ b/src/tracing/internal/tracing_muxer_impl_integrationtest.cc
@@ -1,8 +1,8 @@
 #include "perfetto/tracing/tracing.h"
 
 #include <stdio.h>
+#include <optional>
 
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/thread_task_runner.h"
 #include "perfetto/ext/base/waitable_event.h"
 #include "perfetto/ext/tracing/ipc/service_ipc_host.h"
@@ -53,7 +53,7 @@
 
   struct EnvVar {
     const char* name;
-    base::Optional<std::string> value;
+    std::optional<std::string> value;
   };
   // Stores previous values of environment variables overridden by tests. We
   // need to to this because some android integration tests need to talk to the
diff --git a/test/end_to_end_shared_memory_fuzzer.cc b/test/end_to_end_shared_memory_fuzzer.cc
index 91f3629..adde520 100644
--- a/test/end_to_end_shared_memory_fuzzer.cc
+++ b/test/end_to_end_shared_memory_fuzzer.cc
@@ -132,7 +132,7 @@
   }
 
  private:
-  base::Optional<base::ThreadTaskRunner> runner_;  // Keep first.
+  std::optional<base::ThreadTaskRunner> runner_;  // Keep first.
 
   std::unique_ptr<FakeProducer> producer_;
   const uint8_t* data_;
diff --git a/test/ftrace_integrationtest.cc b/test/ftrace_integrationtest.cc
index ab86dd5..318b308 100644
--- a/test/ftrace_integrationtest.cc
+++ b/test/ftrace_integrationtest.cc
@@ -319,7 +319,7 @@
   const auto& packets = helper.trace();
   ASSERT_GT(packets.size(), 0u);
 
-  base::Optional<protos::gen::FtraceStats> stats;
+  std::optional<protos::gen::FtraceStats> stats;
   for (const auto& packet : packets) {
     if (!packet.has_ftrace_stats() ||
         packet.ftrace_stats().phase() !=
diff --git a/test/test_helper.h b/test/test_helper.h
index c8d1b48..dd18b4c 100644
--- a/test/test_helper.h
+++ b/test/test_helper.h
@@ -19,10 +19,10 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <optional>
 
 #include "perfetto/base/build_config.h"
 #include "perfetto/ext/base/file_utils.h"
-#include "perfetto/ext/base/optional.h"
 #include "perfetto/ext/base/scoped_file.h"
 #include "perfetto/ext/base/subprocess.h"
 #include "perfetto/ext/base/thread_task_runner.h"
@@ -109,7 +109,7 @@
  private:
   struct Var {
     const char* name;
-    base::Optional<std::string> value;
+    std::optional<std::string> value;
   };
   std::vector<Var> prev_state_;
 };
@@ -159,7 +159,7 @@
   base::ThreadTaskRunner* runner() { return runner_ ? &*runner_ : nullptr; }
 
  private:
-  base::Optional<base::ThreadTaskRunner> runner_;  // Keep first.
+  std::optional<base::ThreadTaskRunner> runner_;  // Keep first.
 
   std::string producer_socket_;
   std::string consumer_socket_;
@@ -196,7 +196,7 @@
   }
 
  private:
-  base::Optional<base::ThreadTaskRunner> runner_;  // Keep first.
+  std::optional<base::ThreadTaskRunner> runner_;  // Keep first.
 
   std::string producer_socket_;
   std::unique_ptr<ProbesProducer> producer_;
@@ -253,7 +253,7 @@
   }
 
  private:
-  base::Optional<base::ThreadTaskRunner> runner_;  // Keep first.
+  std::optional<base::ThreadTaskRunner> runner_;  // Keep first.
 
   std::string producer_socket_;
   std::unique_ptr<FakeProducer> producer_;