diff --git a/base/containers/span.h b/base/containers/span.h
index dec3513692852b..f3cdd2f76210e2 100644
--- a/base/containers/span.h
+++ b/base/containers/span.h
@@ -424,6 +424,39 @@ class span : public internal::ExtentStorage<Extent> {
 template <class T, size_t Extent>
 constexpr size_t span<T, Extent>::extent;
 
+// [span.comparison], span comparison operators
+// Relational operators. Equality is a element-wise comparison.
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator==(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend());
+}
+
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator!=(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return !(lhs == rhs);
+}
+
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator<(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return std::lexicographical_compare(lhs.cbegin(), lhs.cend(), rhs.cbegin(),
+                                      rhs.cend());
+}
+
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator<=(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return !(rhs < lhs);
+}
+
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator>(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return rhs < lhs;
+}
+
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator>=(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return !(lhs < rhs);
+}
+
 // [span.objectrep], views of object representation
 template <typename T, size_t X>
 span<const uint8_t, (X == dynamic_extent ? dynamic_extent : sizeof(T) * X)>
diff --git a/base/containers/span_unittest.cc b/base/containers/span_unittest.cc
index 6a123f6b390625..d1ea2e4bd9705f 100644
--- a/base/containers/span_unittest.cc
+++ b/base/containers/span_unittest.cc
@@ -274,13 +274,11 @@ TEST(SpanTest, ConvertBetweenEquivalentTypes) {
 
   span<int32_t> int32_t_span(vector);
   span<int> converted_span(int32_t_span);
-  EXPECT_EQ(int32_t_span.data(), converted_span.data());
-  EXPECT_EQ(int32_t_span.size(), converted_span.size());
+  EXPECT_EQ(int32_t_span, converted_span);
 
   span<int32_t, 5> static_int32_t_span(vector);
   span<int, 5> static_converted_span(static_int32_t_span);
-  EXPECT_EQ(static_int32_t_span.data(), static_converted_span.data());
-  EXPECT_EQ(static_int32_t_span.size(), static_converted_span.size());
+  EXPECT_EQ(static_int32_t_span, static_converted_span);
 }
 
 TEST(SpanTest, TemplatedFirst) {
@@ -908,6 +906,122 @@ TEST(SpanTest, ReverseIterator) {
                          span.crbegin(), span.crend()));
 }
 
+TEST(SpanTest, Equality) {
+  static constexpr int kArray1[] = {3, 1, 4, 1, 5};
+  static constexpr int kArray2[] = {3, 1, 4, 1, 5};
+  constexpr span<const int> span1(kArray1);
+  constexpr span<const int, 5> span2(kArray2);
+
+  EXPECT_EQ(span1, span2);
+
+  static constexpr int kArray3[] = {2, 7, 1, 8, 3};
+  constexpr span<const int> span3(kArray3);
+
+  EXPECT_FALSE(span1 == span3);
+
+  static double kArray4[] = {2.0, 7.0, 1.0, 8.0, 3.0};
+  span<double, 5> span4(kArray4);
+
+  EXPECT_EQ(span3, span4);
+}
+
+TEST(SpanTest, Inequality) {
+  static constexpr int kArray1[] = {2, 3, 5, 7, 11};
+  static constexpr int kArray2[] = {1, 4, 6, 8, 9};
+  constexpr span<const int> span1(kArray1);
+  constexpr span<const int, 5> span2(kArray2);
+
+  EXPECT_NE(span1, span2);
+
+  static constexpr int kArray3[] = {2, 3, 5, 7, 11};
+  constexpr span<const int> span3(kArray3);
+
+  EXPECT_FALSE(span1 != span3);
+
+  static double kArray4[] = {1.0, 4.0, 6.0, 8.0, 9.0};
+  span<double, 5> span4(kArray4);
+
+  EXPECT_NE(span3, span4);
+}
+
+TEST(SpanTest, LessThan) {
+  static constexpr int kArray1[] = {2, 3, 5, 7, 11};
+  static constexpr int kArray2[] = {2, 3, 5, 7, 11, 13};
+  constexpr span<const int> span1(kArray1);
+  constexpr span<const int, 6> span2(kArray2);
+
+  EXPECT_LT(span1, span2);
+
+  static constexpr int kArray3[] = {2, 3, 5, 7, 11};
+  constexpr span<const int> span3(kArray3);
+
+  EXPECT_FALSE(span1 < span3);
+
+  static double kArray4[] = {2.0, 3.0, 5.0, 7.0, 11.0, 13.0};
+  span<double, 6> span4(kArray4);
+
+  EXPECT_LT(span3, span4);
+}
+
+TEST(SpanTest, LessEqual) {
+  static constexpr int kArray1[] = {2, 3, 5, 7, 11};
+  static constexpr int kArray2[] = {2, 3, 5, 7, 11, 13};
+  constexpr span<const int> span1(kArray1);
+  constexpr span<const int, 6> span2(kArray2);
+
+  EXPECT_LE(span1, span1);
+  EXPECT_LE(span1, span2);
+
+  static constexpr int kArray3[] = {2, 3, 5, 7, 10};
+  constexpr span<const int> span3(kArray3);
+
+  EXPECT_FALSE(span1 <= span3);
+
+  static double kArray4[] = {2.0, 3.0, 5.0, 7.0, 11.0, 13.0};
+  span<double, 6> span4(kArray4);
+
+  EXPECT_LE(span3, span4);
+}
+
+TEST(SpanTest, GreaterThan) {
+  static constexpr int kArray1[] = {2, 3, 5, 7, 11, 13};
+  static constexpr int kArray2[] = {2, 3, 5, 7, 11};
+  constexpr span<const int> span1(kArray1);
+  constexpr span<const int, 5> span2(kArray2);
+
+  EXPECT_GT(span1, span2);
+
+  static constexpr int kArray3[] = {2, 3, 5, 7, 11, 13};
+  constexpr span<const int> span3(kArray3);
+
+  EXPECT_FALSE(span1 > span3);
+
+  static double kArray4[] = {2.0, 3.0, 5.0, 7.0, 11.0};
+  span<double, 5> span4(kArray4);
+
+  EXPECT_GT(span3, span4);
+}
+
+TEST(SpanTest, GreaterEqual) {
+  static constexpr int kArray1[] = {2, 3, 5, 7, 11, 13};
+  static constexpr int kArray2[] = {2, 3, 5, 7, 11};
+  constexpr span<const int> span1(kArray1);
+  constexpr span<const int, 5> span2(kArray2);
+
+  EXPECT_GE(span1, span1);
+  EXPECT_GE(span1, span2);
+
+  static constexpr int kArray3[] = {2, 3, 5, 7, 12};
+  constexpr span<const int> span3(kArray3);
+
+  EXPECT_FALSE(span1 >= span3);
+
+  static double kArray4[] = {2.0, 3.0, 5.0, 7.0, 11.0};
+  span<double, 5> span4(kArray4);
+
+  EXPECT_GE(span3, span4);
+}
+
 TEST(SpanTest, AsBytes) {
   {
     constexpr int kArray[] = {2, 3, 5, 7, 11, 13};
@@ -951,8 +1065,7 @@ TEST(SpanTest, MakeSpanFromDataAndSize) {
   std::vector<int> vector = {1, 1, 2, 3, 5, 8};
   span<int> span(vector.data(), vector.size());
   auto made_span = make_span(vector.data(), vector.size());
-  EXPECT_EQ(span.data(), made_span.data());
-  EXPECT_EQ(span.size(), made_span.size());
+  EXPECT_EQ(span, made_span);
   static_assert(decltype(made_span)::extent == dynamic_extent, "");
 }
 
@@ -965,56 +1078,49 @@ TEST(SpanTest, MakeSpanFromPointerPair) {
   std::vector<int> vector = {1, 1, 2, 3, 5, 8};
   span<int> span(vector.data(), vector.size());
   auto made_span = make_span(vector.data(), vector.data() + vector.size());
-  EXPECT_EQ(span.data(), made_span.data());
-  EXPECT_EQ(span.size(), made_span.size());
+  EXPECT_EQ(span, made_span);
   static_assert(decltype(made_span)::extent == dynamic_extent, "");
 }
 
 TEST(SpanTest, MakeSpanFromConstexprArray) {
   static constexpr int kArray[] = {1, 2, 3, 4, 5};
   constexpr span<const int> span(kArray);
-  EXPECT_EQ(span.data(), make_span(kArray).data());
-  EXPECT_EQ(span.size(), make_span(kArray).size());
+  EXPECT_EQ(span, make_span(kArray));
   static_assert(decltype(make_span(kArray))::extent == 5, "");
 }
 
 TEST(SpanTest, MakeSpanFromStdArray) {
   const std::array<int, 5> kArray = {{1, 2, 3, 4, 5}};
   span<const int> span(kArray);
-  EXPECT_EQ(span.data(), make_span(kArray).data());
-  EXPECT_EQ(span.size(), make_span(kArray).size());
+  EXPECT_EQ(span, make_span(kArray));
   static_assert(decltype(make_span(kArray))::extent == 5, "");
 }
 
 TEST(SpanTest, MakeSpanFromConstContainer) {
   const std::vector<int> vector = {-1, -2, -3, -4, -5};
   span<const int> span(vector);
-  EXPECT_EQ(span.data(), make_span(vector).data());
-  EXPECT_EQ(span.size(), make_span(vector).size());
+  EXPECT_EQ(span, make_span(vector));
   static_assert(decltype(make_span(vector))::extent == dynamic_extent, "");
 }
 
 TEST(SpanTest, MakeStaticSpanFromConstContainer) {
   const std::vector<int> vector = {-1, -2, -3, -4, -5};
   span<const int, 5> span(vector);
-  EXPECT_EQ(span.data(), make_span<5>(vector).data());
-  EXPECT_EQ(span.size(), make_span<5>(vector).size());
+  EXPECT_EQ(span, make_span<5>(vector));
   static_assert(decltype(make_span<5>(vector))::extent == 5, "");
 }
 
 TEST(SpanTest, MakeSpanFromContainer) {
   std::vector<int> vector = {-1, -2, -3, -4, -5};
   span<int> span(vector);
-  EXPECT_EQ(span.data(), make_span(vector).data());
-  EXPECT_EQ(span.size(), make_span(vector).size());
+  EXPECT_EQ(span, make_span(vector));
   static_assert(decltype(make_span(vector))::extent == dynamic_extent, "");
 }
 
 TEST(SpanTest, MakeStaticSpanFromContainer) {
   std::vector<int> vector = {-1, -2, -3, -4, -5};
   span<int, 5> span(vector);
-  EXPECT_EQ(span.data(), make_span<5>(vector).data());
-  EXPECT_EQ(span.size(), make_span<5>(vector).size());
+  EXPECT_EQ(span, make_span<5>(vector));
   static_assert(decltype(make_span<5>(vector))::extent == 5, "");
 }
 
diff --git a/device/fido/ble/fido_ble_frames_unittest.cc b/device/fido/ble/fido_ble_frames_unittest.cc
index ba9c4bdae3ebca..2d20c8d5370a9e 100644
--- a/device/fido/ble/fido_ble_frames_unittest.cc
+++ b/device/fido/ble/fido_ble_frames_unittest.cc
@@ -4,7 +4,6 @@
 
 #include "device/fido/ble/fido_ble_frames.h"
 
-#include <algorithm>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ -39,9 +38,7 @@ TEST(FidoBleFramesTest, InitializationFragment) {
       FidoBleFrameInitializationFragment::Parse(buffer, &parsed_fragment));
 
   EXPECT_EQ(kDataLength, parsed_fragment.data_length());
-  EXPECT_TRUE(std::equal(data.begin(), data.end(),
-                         parsed_fragment.fragment().begin(),
-                         parsed_fragment.fragment().end()));
+  EXPECT_EQ(base::make_span(data), parsed_fragment.fragment());
   EXPECT_EQ(FidoBleDeviceCommand::kMsg, parsed_fragment.command());
 }
 
@@ -61,9 +58,7 @@ TEST(FidoBleFramesTest, ContinuationFragment) {
   ASSERT_TRUE(
       FidoBleFrameContinuationFragment::Parse(buffer, &parsed_fragment));
 
-  EXPECT_TRUE(std::equal(data.begin(), data.end(),
-                         parsed_fragment.fragment().begin(),
-                         parsed_fragment.fragment().end()));
+  EXPECT_EQ(base::make_span(data), parsed_fragment.fragment());
   EXPECT_EQ(kSequence, parsed_fragment.sequence());
 }
 
diff --git a/device/fido/cable/fido_cable_discovery_unittest.cc b/device/fido/cable/fido_cable_discovery_unittest.cc
index 138f23379b3ecd..5e8ed7f41e9f63 100644
--- a/device/fido/cable/fido_cable_discovery_unittest.cc
+++ b/device/fido/cable/fido_cable_discovery_unittest.cc
@@ -116,9 +116,8 @@ MATCHER_P2(IsAdvertisementContent,
          manufacturer_data_payload[1] == 0x15 &&  // Manufacturer Data Type
          manufacturer_data_payload[2] == 0x20 &&  // Cable Flags
          manufacturer_data_payload[3] == kTestCableVersionNumber &&
-         std::equal(manufacturer_data_payload.begin() + 4,
-                    manufacturer_data_payload.end(),
-                    expected_client_eid.begin(), expected_client_eid.end());
+         base::make_span(manufacturer_data_payload).subspan(4) ==
+             expected_client_eid;
 
 #elif defined(OS_LINUX) || defined(OS_CHROMEOS)
   const auto service_data = arg->service_data();
@@ -132,8 +131,7 @@ MATCHER_P2(IsAdvertisementContent,
   return (service_data_value[0] >> 5 & 1) &&
          service_data_value[1] == kTestCableVersionNumber &&
          service_data_value.size() == 18u &&
-         std::equal(service_data_value.begin() + 2, service_data_value.end(),
-                    expected_client_eid.begin(), expected_client_eid.end());
+         base::make_span(service_data_value).subspan(2) == expected_client_eid;
 
 #endif
 
diff --git a/device/fido/fido_parsing_utils.h b/device/fido/fido_parsing_utils.h
index fa6d5d2fdc9c6c..6bf982dad912d5 100644
--- a/device/fido/fido_parsing_utils.h
+++ b/device/fido/fido_parsing_utils.h
@@ -10,7 +10,6 @@
 
 #include <algorithm>
 #include <array>
-#include <iterator>
 #include <utility>
 #include <vector>
 
@@ -23,16 +22,14 @@
 namespace device {
 namespace fido_parsing_utils {
 
-// Comparator object that calls std::lexicographical_compare on the begin and
-// end iterators of the passed in ranges. Useful when comparing sequence
-// containers that are of different types, but have similar semantics.
-struct RangeLess {
+// Comparator object that calls base::make_span on its arguments before
+// comparing them with operator<. Useful when comparing sequence containers that
+// are of different types, but have similar semantics.
+struct SpanLess {
   template <typename T, typename U>
   constexpr bool operator()(T&& lhs, U&& rhs) const {
-    using std::begin;
-    using std::end;
-    return std::lexicographical_compare(begin(lhs), end(lhs), begin(rhs),
-                                        end(rhs));
+    return base::make_span(std::forward<T>(lhs)) <
+           base::make_span(std::forward<U>(rhs));
   }
 
   using is_transparent = void;
diff --git a/device/fido/fido_parsing_utils_unittest.cc b/device/fido/fido_parsing_utils_unittest.cc
index a553d4dcdb2cf7..41ff123f59514b 100644
--- a/device/fido/fido_parsing_utils_unittest.cc
+++ b/device/fido/fido_parsing_utils_unittest.cc
@@ -20,64 +20,64 @@ constexpr uint8_t kThree[] = {0x03};
 constexpr uint8_t kOneTwoThree[] = {0x01, 0x02, 0x03};
 }  // namespace
 
-TEST(U2fParsingUtils, RangeLess) {
+TEST(U2fParsingUtils, SpanLess) {
   const std::array<int, 4> kOneTwoThreeFour = {1, 2, 3, 4};
 
-  EXPECT_FALSE(RangeLess()(kOne, kOne));
-  EXPECT_TRUE(RangeLess()(kOne, kOneTwo));
-  EXPECT_TRUE(RangeLess()(kOne, kTwo));
-  EXPECT_TRUE(RangeLess()(kOne, kTwoThree));
-  EXPECT_TRUE(RangeLess()(kOne, kThree));
-  EXPECT_TRUE(RangeLess()(kOne, kOneTwoThree));
-  EXPECT_TRUE(RangeLess()(kOne, kOneTwoThreeFour));
-
-  EXPECT_FALSE(RangeLess()(kOneTwo, kOne));
-  EXPECT_FALSE(RangeLess()(kOneTwo, kOneTwo));
-  EXPECT_TRUE(RangeLess()(kOneTwo, kTwo));
-  EXPECT_TRUE(RangeLess()(kOneTwo, kTwoThree));
-  EXPECT_TRUE(RangeLess()(kOneTwo, kThree));
-  EXPECT_TRUE(RangeLess()(kOneTwo, kOneTwoThree));
-  EXPECT_TRUE(RangeLess()(kOneTwo, kOneTwoThreeFour));
-
-  EXPECT_FALSE(RangeLess()(kTwo, kOne));
-  EXPECT_FALSE(RangeLess()(kTwo, kOneTwo));
-  EXPECT_FALSE(RangeLess()(kTwo, kTwo));
-  EXPECT_TRUE(RangeLess()(kTwo, kTwoThree));
-  EXPECT_TRUE(RangeLess()(kTwo, kThree));
-  EXPECT_FALSE(RangeLess()(kTwo, kOneTwoThree));
-  EXPECT_FALSE(RangeLess()(kTwo, kOneTwoThreeFour));
-
-  EXPECT_FALSE(RangeLess()(kTwoThree, kOne));
-  EXPECT_FALSE(RangeLess()(kTwoThree, kOneTwo));
-  EXPECT_FALSE(RangeLess()(kTwoThree, kTwo));
-  EXPECT_FALSE(RangeLess()(kTwoThree, kTwoThree));
-  EXPECT_TRUE(RangeLess()(kTwoThree, kThree));
-  EXPECT_FALSE(RangeLess()(kTwoThree, kOneTwoThree));
-  EXPECT_FALSE(RangeLess()(kTwoThree, kOneTwoThreeFour));
-
-  EXPECT_FALSE(RangeLess()(kThree, kOne));
-  EXPECT_FALSE(RangeLess()(kThree, kOneTwo));
-  EXPECT_FALSE(RangeLess()(kThree, kTwo));
-  EXPECT_FALSE(RangeLess()(kThree, kTwoThree));
-  EXPECT_FALSE(RangeLess()(kThree, kThree));
-  EXPECT_FALSE(RangeLess()(kThree, kOneTwoThree));
-  EXPECT_FALSE(RangeLess()(kThree, kOneTwoThreeFour));
-
-  EXPECT_FALSE(RangeLess()(kOneTwoThree, kOne));
-  EXPECT_FALSE(RangeLess()(kOneTwoThree, kOneTwo));
-  EXPECT_TRUE(RangeLess()(kOneTwoThree, kTwo));
-  EXPECT_TRUE(RangeLess()(kOneTwoThree, kTwoThree));
-  EXPECT_TRUE(RangeLess()(kOneTwoThree, kThree));
-  EXPECT_FALSE(RangeLess()(kOneTwoThree, kOneTwoThree));
-  EXPECT_TRUE(RangeLess()(kOneTwoThree, kOneTwoThreeFour));
-
-  EXPECT_FALSE(RangeLess()(kOneTwoThreeFour, kOne));
-  EXPECT_FALSE(RangeLess()(kOneTwoThreeFour, kOneTwo));
-  EXPECT_TRUE(RangeLess()(kOneTwoThreeFour, kTwo));
-  EXPECT_TRUE(RangeLess()(kOneTwoThreeFour, kTwoThree));
-  EXPECT_TRUE(RangeLess()(kOneTwoThreeFour, kThree));
-  EXPECT_FALSE(RangeLess()(kOneTwoThreeFour, kOneTwoThree));
-  EXPECT_FALSE(RangeLess()(kOneTwoThreeFour, kOneTwoThreeFour));
+  EXPECT_FALSE(SpanLess()(kOne, kOne));
+  EXPECT_TRUE(SpanLess()(kOne, kOneTwo));
+  EXPECT_TRUE(SpanLess()(kOne, kTwo));
+  EXPECT_TRUE(SpanLess()(kOne, kTwoThree));
+  EXPECT_TRUE(SpanLess()(kOne, kThree));
+  EXPECT_TRUE(SpanLess()(kOne, kOneTwoThree));
+  EXPECT_TRUE(SpanLess()(kOne, kOneTwoThreeFour));
+
+  EXPECT_FALSE(SpanLess()(kOneTwo, kOne));
+  EXPECT_FALSE(SpanLess()(kOneTwo, kOneTwo));
+  EXPECT_TRUE(SpanLess()(kOneTwo, kTwo));
+  EXPECT_TRUE(SpanLess()(kOneTwo, kTwoThree));
+  EXPECT_TRUE(SpanLess()(kOneTwo, kThree));
+  EXPECT_TRUE(SpanLess()(kOneTwo, kOneTwoThree));
+  EXPECT_TRUE(SpanLess()(kOneTwo, kOneTwoThreeFour));
+
+  EXPECT_FALSE(SpanLess()(kTwo, kOne));
+  EXPECT_FALSE(SpanLess()(kTwo, kOneTwo));
+  EXPECT_FALSE(SpanLess()(kTwo, kTwo));
+  EXPECT_TRUE(SpanLess()(kTwo, kTwoThree));
+  EXPECT_TRUE(SpanLess()(kTwo, kThree));
+  EXPECT_FALSE(SpanLess()(kTwo, kOneTwoThree));
+  EXPECT_FALSE(SpanLess()(kTwo, kOneTwoThreeFour));
+
+  EXPECT_FALSE(SpanLess()(kTwoThree, kOne));
+  EXPECT_FALSE(SpanLess()(kTwoThree, kOneTwo));
+  EXPECT_FALSE(SpanLess()(kTwoThree, kTwo));
+  EXPECT_FALSE(SpanLess()(kTwoThree, kTwoThree));
+  EXPECT_TRUE(SpanLess()(kTwoThree, kThree));
+  EXPECT_FALSE(SpanLess()(kTwoThree, kOneTwoThree));
+  EXPECT_FALSE(SpanLess()(kTwoThree, kOneTwoThreeFour));
+
+  EXPECT_FALSE(SpanLess()(kThree, kOne));
+  EXPECT_FALSE(SpanLess()(kThree, kOneTwo));
+  EXPECT_FALSE(SpanLess()(kThree, kTwo));
+  EXPECT_FALSE(SpanLess()(kThree, kTwoThree));
+  EXPECT_FALSE(SpanLess()(kThree, kThree));
+  EXPECT_FALSE(SpanLess()(kThree, kOneTwoThree));
+  EXPECT_FALSE(SpanLess()(kThree, kOneTwoThreeFour));
+
+  EXPECT_FALSE(SpanLess()(kOneTwoThree, kOne));
+  EXPECT_FALSE(SpanLess()(kOneTwoThree, kOneTwo));
+  EXPECT_TRUE(SpanLess()(kOneTwoThree, kTwo));
+  EXPECT_TRUE(SpanLess()(kOneTwoThree, kTwoThree));
+  EXPECT_TRUE(SpanLess()(kOneTwoThree, kThree));
+  EXPECT_FALSE(SpanLess()(kOneTwoThree, kOneTwoThree));
+  EXPECT_TRUE(SpanLess()(kOneTwoThree, kOneTwoThreeFour));
+
+  EXPECT_FALSE(SpanLess()(kOneTwoThreeFour, kOne));
+  EXPECT_FALSE(SpanLess()(kOneTwoThreeFour, kOneTwo));
+  EXPECT_TRUE(SpanLess()(kOneTwoThreeFour, kTwo));
+  EXPECT_TRUE(SpanLess()(kOneTwoThreeFour, kTwoThree));
+  EXPECT_TRUE(SpanLess()(kOneTwoThreeFour, kThree));
+  EXPECT_FALSE(SpanLess()(kOneTwoThreeFour, kOneTwoThree));
+  EXPECT_FALSE(SpanLess()(kOneTwoThreeFour, kOneTwoThreeFour));
 }
 
 TEST(U2fParsingUtils, Materialize) {
diff --git a/device/fido/hid/fido_hid_device.cc b/device/fido/hid/fido_hid_device.cc
index db134be7e04ca0..9734a739218e2e 100644
--- a/device/fido/hid/fido_hid_device.cc
+++ b/device/fido/hid/fido_hid_device.cc
@@ -167,8 +167,7 @@ void FidoHidDevice::OnAllocateChannel(std::vector<uint8_t> nonce,
   auto received_nonce = base::make_span(payload).first(8);
   // Received a broadcast message for a different client. Disregard and continue
   // reading.
-  if (!std::equal(nonce.begin(), nonce.end(), received_nonce.begin(),
-                  received_nonce.end())) {
+  if (base::make_span(nonce) != received_nonce) {
     auto repeating_callback =
         base::AdaptCallbackForRepeating(std::move(callback));
     ArmTimeout(repeating_callback);
diff --git a/device/fido/virtual_fido_device.cc b/device/fido/virtual_fido_device.cc
index 4ce078679e6bea..755e53909bd7a2 100644
--- a/device/fido/virtual_fido_device.cc
+++ b/device/fido/virtual_fido_device.cc
@@ -4,7 +4,6 @@
 
 #include "device/fido/virtual_fido_device.h"
 
-#include <algorithm>
 #include <tuple>
 #include <utility>
 
@@ -157,11 +156,9 @@ VirtualFidoDevice::RegistrationData* VirtualFidoDevice::FindRegistrationData(
   if (it == mutable_state()->registrations.end())
     return nullptr;
 
-  if (!std::equal(application_parameter.begin(), application_parameter.end(),
-                  it->second.application_parameter.begin(),
-                  it->second.application_parameter.end())) {
+  if (application_parameter !=
+      base::make_span(it->second.application_parameter))
     return nullptr;
-  }
 
   return &(it->second);
 }
diff --git a/device/fido/virtual_fido_device.h b/device/fido/virtual_fido_device.h
index c6cfb19187b815..782eee329c2579 100644
--- a/device/fido/virtual_fido_device.h
+++ b/device/fido/virtual_fido_device.h
@@ -70,7 +70,7 @@ class COMPONENT_EXPORT(DEVICE_FIDO) VirtualFidoDevice : public FidoDevice {
     // Registered keys. Keyed on key handle (a.k.a. "credential ID").
     std::map<std::vector<uint8_t>,
              RegistrationData,
-             fido_parsing_utils::RangeLess>
+             fido_parsing_utils::SpanLess>
         registrations;
 
     // If set, this callback is called whenever a "press" is required. It allows
diff --git a/media/cdm/cbcs_decryptor_unittest.cc b/media/cdm/cbcs_decryptor_unittest.cc
index 1d4192028bd978..fa6a1aa1074bfb 100644
--- a/media/cdm/cbcs_decryptor_unittest.cc
+++ b/media/cdm/cbcs_decryptor_unittest.cc
@@ -4,7 +4,6 @@
 
 #include "media/cdm/cbcs_decryptor.h"
 
-#include <algorithm>
 #include <array>
 #include <memory>
 
@@ -178,11 +177,10 @@ TEST_F(CbcsDecryptorTest, AdditionalData) {
   EXPECT_EQ(encrypted_buffer->is_key_frame(), decrypted_buffer->is_key_frame());
   EXPECT_EQ(encrypted_buffer->side_data_size(),
             decrypted_buffer->side_data_size());
-  EXPECT_TRUE(std::equal(
-      encrypted_buffer->side_data(),
-      encrypted_buffer->side_data() + encrypted_buffer->side_data_size(),
-      decrypted_buffer->side_data(),
-      decrypted_buffer->side_data() + encrypted_buffer->side_data_size()));
+  EXPECT_EQ(base::make_span(encrypted_buffer->side_data(),
+                            encrypted_buffer->side_data_size()),
+            base::make_span(decrypted_buffer->side_data(),
+                            decrypted_buffer->side_data_size()));
 }
 
 TEST_F(CbcsDecryptorTest, DifferentPattern) {
diff --git a/media/cdm/cenc_decryptor_unittest.cc b/media/cdm/cenc_decryptor_unittest.cc
index 3a8c383a540b30..441c2c41b7a9d2 100644
--- a/media/cdm/cenc_decryptor_unittest.cc
+++ b/media/cdm/cenc_decryptor_unittest.cc
@@ -6,7 +6,6 @@
 
 #include <stdint.h>
 
-#include <algorithm>
 #include <string>
 #include <vector>
 
@@ -161,11 +160,10 @@ TEST_F(CencDecryptorTest, ExtraData) {
   EXPECT_EQ(encrypted_buffer->is_key_frame(), decrypted_buffer->is_key_frame());
   EXPECT_EQ(encrypted_buffer->side_data_size(),
             decrypted_buffer->side_data_size());
-  EXPECT_TRUE(std::equal(
-      encrypted_buffer->side_data(),
-      encrypted_buffer->side_data() + encrypted_buffer->side_data_size(),
-      decrypted_buffer->side_data(),
-      decrypted_buffer->side_data() + encrypted_buffer->side_data_size()));
+  EXPECT_EQ(base::make_span(encrypted_buffer->side_data(),
+                            encrypted_buffer->side_data_size()),
+            base::make_span(decrypted_buffer->side_data(),
+                            decrypted_buffer->side_data_size()));
 }
 
 TEST_F(CencDecryptorTest, NoSubsamples) {
diff --git a/mojo/public/cpp/base/read_only_buffer_unittest.cc b/mojo/public/cpp/base/read_only_buffer_unittest.cc
index ad1440795c1565..990cb36a0f5c26 100644
--- a/mojo/public/cpp/base/read_only_buffer_unittest.cc
+++ b/mojo/public/cpp/base/read_only_buffer_unittest.cc
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <algorithm>
-
 #include "mojo/public/cpp/base/read_only_buffer_mojom_traits.h"
 #include "mojo/public/cpp/test_support/test_utils.h"
 #include "mojo/public/mojom/base/read_only_buffer.mojom.h"
@@ -18,7 +16,7 @@ TEST(ReadOnlyBufferTest, ReadOnlyBufferEmptySpan) {
 
   ASSERT_TRUE(
       mojo::test::SerializeAndDeserialize<mojom::ReadOnlyBuffer>(&in, &out));
-  EXPECT_TRUE(std::equal(in.begin(), in.end(), out.begin(), out.end()));
+  EXPECT_EQ(in, out);
 }
 
 TEST(ReadOnlyBufferTest, ReadOnlyBufferNonEmptySpan) {
@@ -32,7 +30,7 @@ TEST(ReadOnlyBufferTest, ReadOnlyBufferNonEmptySpan) {
   std::vector<uint8_t> data = mojom::ReadOnlyBuffer::Serialize(&in);
 
   EXPECT_TRUE(mojom::ReadOnlyBuffer::Deserialize(std::move(data), &out));
-  EXPECT_TRUE(std::equal(in.begin(), in.end(), out.begin(), out.end()));
+  EXPECT_EQ(in, out);
 }
 
 }  // namespace read_only_buffer_unittest
diff --git a/net/ntlm/ntlm_unittest.cc b/net/ntlm/ntlm_unittest.cc
index 684cdd8803987f..1b852668d29ccd 100644
--- a/net/ntlm/ntlm_unittest.cc
+++ b/net/ntlm/ntlm_unittest.cc
@@ -13,8 +13,6 @@
 
 #include "net/ntlm/ntlm.h"
 
-#include <algorithm>
-#include <iterator>
 #include <string>
 
 #include "base/md5.h"
@@ -64,8 +62,7 @@ TEST(NtlmTest, MapHashToDesKeysAllOnes) {
   // is undefined, so clear it to do memcmp.
   ClearLsb(result);
 
-  EXPECT_TRUE(std::equal(std::begin(expected), std::end(expected),
-                         std::begin(result), std::end(result)));
+  EXPECT_EQ(base::make_span(expected), base::make_span(result));
 }
 
 TEST(NtlmTest, MapHashToDesKeysAllZeros) {
@@ -79,8 +76,7 @@ TEST(NtlmTest, MapHashToDesKeysAllZeros) {
   // is undefined, so clear it to do memcmp.
   ClearLsb(result);
 
-  EXPECT_TRUE(std::equal(std::begin(expected), std::end(expected),
-                         std::begin(result), std::end(result)));
+  EXPECT_EQ(base::make_span(expected), base::make_span(result));
 }
 
 TEST(NtlmTest, MapHashToDesKeysAlternatingBits) {
@@ -97,8 +93,7 @@ TEST(NtlmTest, MapHashToDesKeysAlternatingBits) {
   // is undefined, so clear it to do memcmp.
   ClearLsb(result);
 
-  EXPECT_TRUE(std::equal(std::begin(expected), std::end(expected),
-                         std::begin(result), std::end(result)));
+  EXPECT_EQ(base::make_span(expected), base::make_span(result));
 }
 
 TEST(NtlmTest, GenerateNtlmHashV1PasswordSpecTests) {
diff --git a/storage/browser/blob/blob_builder_from_stream_unittest.cc b/storage/browser/blob/blob_builder_from_stream_unittest.cc
index c1c4af276203e1..4940825bde5833 100644
--- a/storage/browser/blob/blob_builder_from_stream_unittest.cc
+++ b/storage/browser/blob/blob_builder_from_stream_unittest.cc
@@ -4,8 +4,6 @@
 
 #include "storage/browser/blob/blob_builder_from_stream.h"
 
-#include <algorithm>
-
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/rand_util.h"
@@ -132,10 +130,8 @@ class BlobBuilderFromStreamTestWithDelayedLimits
         EXPECT_LE(item->length(), kTestBlobStorageMaxBlobMemorySize);
         ASSERT_LE(next_memory_offset + item->length(), in_memory_data.size());
 
-        EXPECT_TRUE(std::equal(
-            in_memory_data.begin() + next_memory_offset,
-            in_memory_data.begin() + next_memory_offset + item->length(),
-            item->bytes().begin(), item->bytes().end()));
+        EXPECT_EQ(in_memory_data.subspan(next_memory_offset, item->length()),
+                  item->bytes());
 
         next_memory_offset += item->length();
       } else if (item->type() == BlobDataItem::Type::kFile) {
@@ -148,10 +144,8 @@ class BlobBuilderFromStreamTestWithDelayedLimits
         std::string file_contents;
         EXPECT_TRUE(base::ReadFileToString(item->path(), &file_contents));
         EXPECT_EQ(item->length(), file_contents.size());
-        EXPECT_TRUE(
-            std::equal(on_disk_data.begin() + next_file_offset,
-                       on_disk_data.begin() + next_file_offset + item->length(),
-                       file_contents.begin(), file_contents.end()));
+        EXPECT_EQ(on_disk_data.subspan(next_file_offset, item->length()),
+                  base::make_span(file_contents));
 
         next_file_offset += item->length();
         if (next_file_offset < on_disk_data.size()) {
diff --git a/storage/browser/blob/blob_data_item.cc b/storage/browser/blob/blob_data_item.cc
index c500cc0ef276d2..7046bb8e03d4ec 100644
--- a/storage/browser/blob/blob_data_item.cc
+++ b/storage/browser/blob/blob_data_item.cc
@@ -4,7 +4,6 @@
 
 #include "storage/browser/blob/blob_data_item.h"
 
-#include <algorithm>
 #include <memory>
 #include <utility>
 
@@ -212,8 +211,7 @@ bool operator==(const BlobDataItem& a, const BlobDataItem& b) {
     return false;
   switch (a.type()) {
     case BlobDataItem::Type::kBytes:
-      return std::equal(a.bytes().begin(), a.bytes().end(), b.bytes().begin(),
-                        b.bytes().end());
+      return a.bytes() == b.bytes();
     case BlobDataItem::Type::kBytesDescription:
       return true;
     case BlobDataItem::Type::kFile:
diff --git a/third_party/blink/renderer/platform/shared_buffer.h b/third_party/blink/renderer/platform/shared_buffer.h
index 8c01968affef3f..311fb9c5e46ff8 100644
--- a/third_party/blink/renderer/platform/shared_buffer.h
+++ b/third_party/blink/renderer/platform/shared_buffer.h
@@ -27,7 +27,6 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_SHARED_BUFFER_H_
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SHARED_BUFFER_H_
 
-#include <algorithm>
 #include <utility>
 #include <vector>
 
@@ -62,9 +61,7 @@ class PLATFORM_EXPORT SharedBuffer : public RefCounted<SharedBuffer> {
       return temp;
     }
     bool operator==(const Iterator& that) const {
-      return std::equal(value_.begin(), value_.end(), that.value_.begin(),
-                        that.value_.end()) &&
-             buffer_ == that.buffer_;
+      return value_ == that.value_ && buffer_ == that.buffer_;
     }
     bool operator!=(const Iterator& that) const { return !(*this == that); }
     const base::span<const char>& operator*() const {