net: Replace base::Optional and friends with absl counterparts

This replaces:
- base::Optional -> absl::optional
- include "base/optional.h"
  ->
  include "third_party/abseil-cpp/absl/types/optional.h"
- base::nullopt -> absl::nullopt
- base::make_optional -> absl::make_optional

Bug: 1202909
Change-Id: I27d6f81f415e213c1a4997a55c35935a57ba88a4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2896994
Auto-Submit: Anton Bikineev <bikineev@chromium.org>
Commit-Queue: Anton Bikineev <bikineev@chromium.org>
Reviewed-by: Peter Kasting <pkasting@chromium.org>
Owners-Override: Peter Kasting <pkasting@chromium.org>
Cr-Commit-Position: refs/heads/master@{#883294}

net/android/cellular_signal_strength.cc

@@ -29,12 +29,12 @@ static_assert(
 
 }  // namespace
 
-base::Optional<int32_t> GetSignalStrengthLevel() {
+absl::optional<int32_t> GetSignalStrengthLevel() {
   int32_t signal_strength_level =
       Java_AndroidCellularSignalStrength_getSignalStrengthLevel(
           base::android::AttachCurrentThread());
   if (signal_strength_level == ERROR_NOT_SUPPORTED)
-    return base::nullopt;
+    return absl::nullopt;
 
   // |signal_strength_level| is expected to be between 0 and 4 (both inclusive).
   // See

net/android/cellular_signal_strength.h

@@ -8,8 +8,8 @@
 #include <jni.h>
 #include <stdint.h>
 
-#include "base/optional.h"
 #include "net/base/net_export.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
 
 namespace net {
 
@@ -22,7 +22,7 @@ namespace cellular_signal_strength {
 // empty value is returned. If the signal strength value returned by platform
 // API is less than 0, this method returns 0. If the platform API returns a
 // value larger than 4, then this method returns 4.
-NET_EXPORT_PRIVATE base::Optional<int32_t> GetSignalStrengthLevel();
+NET_EXPORT_PRIVATE absl::optional<int32_t> GetSignalStrengthLevel();
 
 }  // namespace cellular_signal_strength
 

net/android/cellular_signal_strength_unittest.cc

@@ -6,16 +6,16 @@
 
 #include <stdint.h>
 
-#include "base/optional.h"
 #include "net/base/network_change_notifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
 
 namespace net {
 
 namespace {
 
 TEST(CellularSignalStrengthAndroidTest, SignalStrengthLevelTest) {
-  base::Optional<int32_t> signal_strength =
+  absl::optional<int32_t> signal_strength =
       android::cellular_signal_strength::GetSignalStrengthLevel();
 
   // Signal strength is unavailable if the device does not have an active

net/android/network_activation_request.h

@@ -38,7 +38,7 @@ class NET_EXPORT_PRIVATE NetworkActivationRequest {
 
   // Exposes a handle to the network currently activated by the system on behalf
   // of this request, if any.
-  const base::Optional<NetworkHandle>& activated_network() const {
+  const absl::optional<NetworkHandle>& activated_network() const {
     return activated_network_;
   }
 
@@ -53,7 +53,7 @@ class NET_EXPORT_PRIVATE NetworkActivationRequest {
   const scoped_refptr<base::SequencedTaskRunner> task_runner_;
   base::WeakPtr<NetworkActivationRequest> weak_self_;
   base::android::ScopedJavaGlobalRef<jobject> java_request_;
-  base::Optional<NetworkHandle> activated_network_;
+  absl::optional<NetworkHandle> activated_network_;
   base::WeakPtrFactory<NetworkActivationRequest> weak_ptr_factory_{this};
 };
 

net/android/network_library.cc

@@ -123,12 +123,12 @@ std::string GetWifiSSID() {
           base::android::AttachCurrentThread()));
 }
 
-base::Optional<int32_t> GetWifiSignalLevel() {
+absl::optional<int32_t> GetWifiSignalLevel() {
   const int count_buckets = 5;
   int signal_strength = Java_AndroidNetworkLibrary_getWifiSignalLevel(
       base::android::AttachCurrentThread(), count_buckets);
   if (signal_strength < 0)
-    return base::nullopt;
+    return absl::nullopt;
   DCHECK_LE(0, signal_strength);
   DCHECK_GE(count_buckets - 1, signal_strength);
 

net/android/network_library.h

@@ -85,7 +85,7 @@ NET_EXPORT_PRIVATE std::string GetWifiSSID();
 // Returns the signal strength level (between 0 and 4, both inclusive) of the
 // currently registered Wifi connection. If the value is unavailable, an
 // empty value is returned.
-NET_EXPORT_PRIVATE base::Optional<int32_t> GetWifiSignalLevel();
+NET_EXPORT_PRIVATE absl::optional<int32_t> GetWifiSignalLevel();
 
 // Gets the DNS servers and puts them in |dns_servers|. Sets
 // |dns_over_tls_active| and |dns_over_tls_hostname| based on the private DNS

net/android/network_library_unittest.cc

@@ -20,7 +20,7 @@ TEST(NetworkLibraryTest, CaptivePortal) {
 }
 
 TEST(NetworkLibraryTest, GetWifiSignalLevel) {
-  base::Optional<int32_t> signal_strength = android::GetWifiSignalLevel();
+  absl::optional<int32_t> signal_strength = android::GetWifiSignalLevel();
   if (!signal_strength.has_value())
     return;
   EXPECT_LE(0, signal_strength.value());

net/base/address_tracker_linux.cc

@@ -13,12 +13,12 @@
 #include "base/callback_helpers.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
-#include "base/optional.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/task/current_thread.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "build/build_config.h"
 #include "net/base/network_interfaces_linux.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
@@ -327,7 +327,7 @@ void AddressTrackerLinux::ReadMessages(bool* address_changed,
   char buffer[4096];
   bool first_loop = true;
   {
-    base::Optional<base::ScopedBlockingCall> blocking_call;
+    absl::optional<base::ScopedBlockingCall> blocking_call;
     if (tracking_) {
       // If the loop below takes a long time to run, a new thread should added
       // to the current thread pool to ensure forward progress of all tasks.

net/base/backoff_entry_serializer_fuzzer.cc

@@ -9,7 +9,6 @@
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
-#include "base/optional.h"
 #include "base/strings/string_piece_forward.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
@@ -18,6 +17,7 @@
 #include "net/base/backoff_entry_serializer_fuzzer_input.pb.h"
 #include "testing/libfuzzer/proto/json_proto_converter.h"
 #include "testing/libfuzzer/proto/lpm_interface.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
 
 namespace net {
 
@@ -50,10 +50,10 @@ class ProtoTranslator {
     return base::TimeTicks() +
            base::TimeDelta::FromMicroseconds(input_.now_ticks());
   }
-  base::Optional<base::Value> serialized_entry() const {
+  absl::optional<base::Value> serialized_entry() const {
     json_proto::JsonProtoConverter converter;
     std::string json_array = converter.Convert(input_.serialized_entry());
-    base::Optional<base::Value> value = base::JSONReader::Read(json_array);
+    absl::optional<base::Value> value = base::JSONReader::Read(json_array);
     return value;
   }
 
@@ -91,7 +91,7 @@ class MockClock : public base::TickClock {
 // we check that the parsed BackoffEntry values are equivalent.
 void TestDeserialize(const ProtoTranslator& translator) {
   // Attempt to convert the json_proto.ArrayValue to a base::Value.
-  base::Optional<base::Value> value = translator.serialized_entry();
+  absl::optional<base::Value> value = translator.serialized_entry();
   if (!value)
     return;
   DCHECK(value->is_list());

net/base/isolation_info.cc

@@ -37,11 +37,11 @@ bool ValidateSameSite(const url::Origin& origin,
 // 0-argument constructor. Additionally, |opaque_and_non_transient| can only be
 // true if both origins are opaque and |site_for_cookies| is null.
 bool IsConsistent(IsolationInfo::RequestType request_type,
-                  const base::Optional<url::Origin>& top_frame_origin,
-                  const base::Optional<url::Origin>& frame_origin,
+                  const absl::optional<url::Origin>& top_frame_origin,
+                  const absl::optional<url::Origin>& frame_origin,
                   const SiteForCookies& site_for_cookies,
                   bool opaque_and_non_transient,
-                  base::Optional<std::set<SchemefulSite>> party_context) {
+                  absl::optional<std::set<SchemefulSite>> party_context) {
   // Check for the default-constructed case.
   if (!top_frame_origin) {
     return request_type == IsolationInfo::RequestType::kOther &&
@@ -92,11 +92,11 @@ bool IsConsistent(IsolationInfo::RequestType request_type,
 
 IsolationInfo::IsolationInfo()
     : IsolationInfo(RequestType::kOther,
-                    base::nullopt,
-                    base::nullopt,
+                    absl::nullopt,
+                    absl::nullopt,
                     SiteForCookies(),
                     false /* opaque_and_non_transient */,
-                    base::nullopt) {}
+                    absl::nullopt) {}
 
 IsolationInfo::IsolationInfo(const IsolationInfo&) = default;
 IsolationInfo::IsolationInfo(IsolationInfo&&) = default;
@@ -116,22 +116,22 @@ IsolationInfo IsolationInfo::CreateTransient() {
   url::Origin opaque_origin;
   return IsolationInfo(RequestType::kOther, opaque_origin, opaque_origin,
                        SiteForCookies(), false /* opaque_and_non_transient */,
-                       base::nullopt /* party_context */);
+                       absl::nullopt /* party_context */);
 }
 
 IsolationInfo IsolationInfo::CreateOpaqueAndNonTransient() {
   url::Origin opaque_origin;
   return IsolationInfo(RequestType::kOther, opaque_origin, opaque_origin,
                        SiteForCookies(), true /* opaque_and_non_transient */,
-                       base::nullopt /* party_context */);
+                       absl::nullopt /* party_context */);
 }
 
 IsolationInfo IsolationInfo::Create(
     RequestType request_type,
     const url::Origin& top_frame_origin,
     const url::Origin& frame_origin,
     const SiteForCookies& site_for_cookies,
-    base::Optional<std::set<SchemefulSite>> party_context) {
+    absl::optional<std::set<SchemefulSite>> party_context) {
   return IsolationInfo(request_type, top_frame_origin, frame_origin,
                        site_for_cookies, false /* opaque_and_non_transient */,
                        std::move(party_context));
@@ -161,20 +161,20 @@ IsolationInfo IsolationInfo::CreatePartial(
 
   return IsolationInfo(request_type, top_frame_origin, frame_origin,
                        SiteForCookies(), opaque_and_non_transient,
-                       base::nullopt /* party_context */);
+                       absl::nullopt /* party_context */);
 }
 
-base::Optional<IsolationInfo> IsolationInfo::CreateIfConsistent(
+absl::optional<IsolationInfo> IsolationInfo::CreateIfConsistent(
     RequestType request_type,
-    const base::Optional<url::Origin>& top_frame_origin,
-    const base::Optional<url::Origin>& frame_origin,
+    const absl::optional<url::Origin>& top_frame_origin,
+    const absl::optional<url::Origin>& frame_origin,
     const SiteForCookies& site_for_cookies,
     bool opaque_and_non_transient,
-    base::Optional<std::set<SchemefulSite>> party_context) {
+    absl::optional<std::set<SchemefulSite>> party_context) {
   if (!IsConsistent(request_type, top_frame_origin, frame_origin,
                     site_for_cookies, opaque_and_non_transient,
                     party_context)) {
-    return base::nullopt;
+    return absl::nullopt;
   }
   return IsolationInfo(request_type, top_frame_origin, frame_origin,
                        site_for_cookies, opaque_and_non_transient,
@@ -221,11 +221,11 @@ IsolationInfo IsolationInfo::ToDoUseTopFrameOriginAsWell(
 
 IsolationInfo::IsolationInfo(
     RequestType request_type,
-    const base::Optional<url::Origin>& top_frame_origin,
-    const base::Optional<url::Origin>& frame_origin,
+    const absl::optional<url::Origin>& top_frame_origin,
+    const absl::optional<url::Origin>& frame_origin,
     const SiteForCookies& site_for_cookies,
     bool opaque_and_non_transient,
-    base::Optional<std::set<SchemefulSite>> party_context)
+    absl::optional<std::set<SchemefulSite>> party_context)
     : request_type_(request_type),
       top_frame_origin_(top_frame_origin),
       frame_origin_(frame_origin),
@@ -239,7 +239,7 @@ IsolationInfo::IsolationInfo(
       opaque_and_non_transient_(opaque_and_non_transient),
       party_context_(party_context.has_value() &&
                              party_context->size() > kPartyContextMaxSize
-                         ? base::nullopt
+                         ? absl::nullopt
                          : party_context) {
   DCHECK(IsConsistent(request_type_, top_frame_origin_, frame_origin_,
                       site_for_cookies_, opaque_and_non_transient_,

net/base/isolation_info.h

@@ -7,10 +7,10 @@
 
 #include <set>
 
-#include "base/optional.h"
 #include "net/base/net_export.h"
 #include "net/base/network_isolation_key.h"
 #include "net/cookies/site_for_cookies.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
 #include "url/origin.h"
 
 namespace network {
@@ -116,7 +116,7 @@ class NET_EXPORT IsolationInfo {
       const url::Origin& top_frame_origin,
       const url::Origin& frame_origin,
       const SiteForCookies& site_for_cookies,
-      base::Optional<std::set<SchemefulSite>> party_context = base::nullopt);
+      absl::optional<std::set<SchemefulSite>> party_context = absl::nullopt);
 
   // Create an IsolationInfos that may not be fully correct - in particular,
   // the SiteForCookies will always set to null, and if the NetworkIsolationKey
@@ -136,13 +136,13 @@ class NET_EXPORT IsolationInfo {
   // considered consistent.
   //
   // Intended for use by cross-process deserialization.
-  static base::Optional<IsolationInfo> CreateIfConsistent(
+  static absl::optional<IsolationInfo> CreateIfConsistent(
       RequestType request_type,
-      const base::Optional<url::Origin>& top_frame_origin,
-      const base::Optional<url::Origin>& frame_origin,
+      const absl::optional<url::Origin>& top_frame_origin,
+      const absl::optional<url::Origin>& frame_origin,
       const SiteForCookies& site_for_cookies,
       bool opaque_and_non_transient,
-      base::Optional<std::set<SchemefulSite>> party_context = base::nullopt);
+      absl::optional<std::set<SchemefulSite>> party_context = absl::nullopt);
 
   // Create a new IsolationInfo for a redirect to the supplied origin. |this| is
   // unmodified.
@@ -166,10 +166,10 @@ class NET_EXPORT IsolationInfo {
   // Note that these are the values the IsolationInfo was created with. In the
   // case an IsolationInfo was created from a NetworkIsolationKey, they may be
   // scheme + eTLD+1 instead of actual origins.
-  const base::Optional<url::Origin>& top_frame_origin() const {
+  const absl::optional<url::Origin>& top_frame_origin() const {
     return top_frame_origin_;
   }
-  const base::Optional<url::Origin>& frame_origin() const {
+  const absl::optional<url::Origin>& frame_origin() const {
     return frame_origin_;
   }
 
@@ -192,24 +192,24 @@ class NET_EXPORT IsolationInfo {
   // TODO(mmenke): Make this function PartyContextForTesting() after switching
   // RenderFrameHostImpl to use the parent IsolationInfo to create the child
   // IsolationInfo instead of walking through all parent frames.
-  const base::Optional<std::set<SchemefulSite>>& party_context() const {
+  const absl::optional<std::set<SchemefulSite>>& party_context() const {
     return party_context_;
   }
 
   bool IsEqualForTesting(const IsolationInfo& other) const;
 
  private:
   IsolationInfo(RequestType request_type,
-                const base::Optional<url::Origin>& top_frame_origin,
-                const base::Optional<url::Origin>& frame_origin,
+                const absl::optional<url::Origin>& top_frame_origin,
+                const absl::optional<url::Origin>& frame_origin,
                 const SiteForCookies& site_for_cookies,
                 bool opaque_and_non_transient,
-                base::Optional<std::set<SchemefulSite>> party_context);
+                absl::optional<std::set<SchemefulSite>> party_context);
 
   RequestType request_type_;
 
-  base::Optional<url::Origin> top_frame_origin_;
-  base::Optional<url::Origin> frame_origin_;
+  absl::optional<url::Origin> top_frame_origin_;
+  absl::optional<url::Origin> frame_origin_;
 
   // This can be deduced from the two origins above, but keep a cached version
   // to avoid repeated eTLD+1 calculations, when this is using eTLD+1.
@@ -236,7 +236,7 @@ class NET_EXPORT IsolationInfo {
   // is still included in the set. The top frame's site is excluded because it
   // is redundant with the |top_frame_origin_| field. The current frame is
   // excluded to make it easier to update on subframe redirects.
-  base::Optional<std::set<SchemefulSite>> party_context_;
+  absl::optional<std::set<SchemefulSite>> party_context_;
 
   // Mojo serialization code needs to access internal party_context_ field.
   friend struct mojo::StructTraits<network::mojom::IsolationInfoDataView,