@fails-components/webtransport 0.0.1 → 0.0.2

package/third_party/boringssl/src/ssl/ssl_test.cc

@@ -8159,5 +8159,106 @@ TEST(SSLTest, NumTickets) {
   EXPECT_EQ(count_tickets(), 16u);
 }
 
+TEST(SSLTest, CertSubjectsToStack) {
+  const std::string kCert1 = R"(
+-----BEGIN CERTIFICATE-----
+MIIBzzCCAXagAwIBAgIJANlMBNpJfb/rMAkGByqGSM49BAEwRTELMAkGA1UEBhMC
+QVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp
+dHMgUHR5IEx0ZDAeFw0xNDA0MjMyMzIxNTdaFw0xNDA1MjMyMzIxNTdaMEUxCzAJ
+BgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5l
+dCBXaWRnaXRzIFB0eSBMdGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATmK2ni
+v2Wfl74vHg2UikzVl2u3qR4NRvvdqakendy6WgHn1peoChj5w8SjHlbifINI2xYa
+HPUdfvGULUvPciLBo1AwTjAdBgNVHQ4EFgQUq4TSrKuV8IJOFngHVVdf5CaNgtEw
+HwYDVR0jBBgwFoAUq4TSrKuV8IJOFngHVVdf5CaNgtEwDAYDVR0TBAUwAwEB/zAJ
+BgcqhkjOPQQBA0gAMEUCIQDyoDVeUTo2w4J5m+4nUIWOcAZ0lVfSKXQA9L4Vh13E
+BwIgfB55FGohg/B6dGh5XxSZmmi08cueFV7mHzJSYV51yRQ=
+-----END CERTIFICATE-----
+)";
+  const std::vector<uint8_t> kName1 = {
+      0x30, 0x45, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
+      0x02, 0x41, 0x55, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08,
+      0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65,
+      0x31, 0x21, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x18, 0x49,
+      0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64, 0x67,
+      0x69, 0x74, 0x73, 0x20, 0x50, 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64};
+  const std::string kCert2 = R"(
+-----BEGIN CERTIFICATE-----
+MIICXjCCAcegAwIBAgIIWjO48ufpunYwDQYJKoZIhvcNAQELBQAwNjEaMBgGA1UE
+ChMRQm9yaW5nU1NMIFRFU1RJTkcxGDAWBgNVBAMTD0ludGVybWVkaWF0ZSBDQTAg
+Fw0xNTAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowMjEaMBgGA1UEChMRQm9y
+aW5nU1NMIFRFU1RJTkcxFDASBgNVBAMTC2V4YW1wbGUuY29tMIGfMA0GCSqGSIb3
+DQEBAQUAA4GNADCBiQKBgQDD0U0ZYgqShJ7oOjsyNKyVXEHqeafmk/bAoPqY/h1c
+oPw2E8KmeqiUSoTPjG5IXSblOxcqpbAXgnjPzo8DI3GNMhAf8SYNYsoH7gc7Uy7j
+5x8bUrisGnuTHqkqH6d4/e7ETJ7i3CpR8bvK16DggEvQTudLipz8FBHtYhFakfdh
+TwIDAQABo3cwdTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEG
+CCsGAQUFBwMCMAwGA1UdEwEB/wQCMAAwGQYDVR0OBBIEEKN5pvbur7mlXjeMEYA0
+4nUwGwYDVR0jBBQwEoAQjBpoqLV2211Xex+NFLIGozANBgkqhkiG9w0BAQsFAAOB
+gQBj/p+JChp//LnXWC1k121LM/ii7hFzQzMrt70bny406SGz9jAjaPOX4S3gt38y
+rhjpPukBlSzgQXFg66y6q5qp1nQTD1Cw6NkKBe9WuBlY3iYfmsf7WT8nhlT1CttU
+xNCwyMX9mtdXdQicOfNjIGUCD5OLV5PgHFPRKiHHioBAhg==
+-----END CERTIFICATE-----
+)";
+  const std::vector<uint8_t> kName2 = {
+      0x30, 0x32, 0x31, 0x1a, 0x30, 0x18, 0x06, 0x03, 0x55, 0x04, 0x0a,
+      0x13, 0x11, 0x42, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x53, 0x4c,
+      0x20, 0x54, 0x45, 0x53, 0x54, 0x49, 0x4e, 0x47, 0x31, 0x14, 0x30,
+      0x12, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0b, 0x65, 0x78, 0x61,
+      0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d};
+
+  const struct {
+    std::vector<std::vector<uint8_t>> existing;
+    std::string pem;
+    std::vector<std::vector<uint8_t>> expected;
+  } kTests[] = {
+      // Do nothing.
+      {{}, "", {}},
+      // Append to an empty list, skipping duplicates.
+      {{}, kCert1 + kCert2 + kCert1, {kName1, kName2}},
+      // One of the names was already present.
+      {{kName1}, kCert1 + kCert2, {kName1, kName2}},
+      // Both names were already present.
+      {{kName1, kName2}, kCert1 + kCert2, {kName1, kName2}},
+      // Preserve existing duplicates.
+      {{kName1, kName2, kName2}, kCert1 + kCert2, {kName1, kName2, kName2}},
+  };
+  for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kTests); i++) {
+    SCOPED_TRACE(i);
+    const auto &t = kTests[i];
+
+    bssl::UniquePtr<STACK_OF(X509_NAME)> stack(sk_X509_NAME_new_null());
+    ASSERT_TRUE(stack);
+    for (const auto& name : t.existing) {
+      const uint8_t *inp = name.data();
+      bssl::UniquePtr<X509_NAME> name_obj(
+          d2i_X509_NAME(nullptr, &inp, name.size()));
+      ASSERT_TRUE(name_obj);
+      EXPECT_EQ(inp, name.data() + name.size());
+      ASSERT_TRUE(bssl::PushToStack(stack.get(), std::move(name_obj)));
+    }
+
+    bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(t.pem.data(), t.pem.size()));
+    ASSERT_TRUE(bio);
+    ASSERT_TRUE(SSL_add_bio_cert_subjects_to_stack(stack.get(), bio.get()));
+
+    // The function should have left |stack|'s comparison function alone.
+    EXPECT_EQ(nullptr, sk_X509_NAME_set_cmp_func(stack.get(), nullptr));
+
+    std::vector<std::vector<uint8_t>> expected = t.expected, result;
+    for (X509_NAME *name : stack.get()) {
+      uint8_t *der = nullptr;
+      int der_len = i2d_X509_NAME(name, &der);
+      ASSERT_GE(der_len, 0);
+      result.push_back(std::vector<uint8_t>(der, der + der_len));
+      OPENSSL_free(der);
+    }
+
+    // |SSL_add_bio_cert_subjects_to_stack| does not return the output in a
+    // well-defined order.
+    std::sort(expected.begin(), expected.end());
+    std::sort(result.begin(), result.end());
+    EXPECT_EQ(result, expected);
+  }
+}
+
 }  // namespace
 BSSL_NAMESPACE_END

package/third_party/boringssl/src/util/doc.config

@@ -48,7 +48,8 @@
       "include/openssl/cipher.h",
       "include/openssl/aead.h",
       "include/openssl/evp.h",
-      "include/openssl/hpke.h"
+      "include/openssl/hpke.h",
+      "include/openssl/kdf.h"
     ]
   },{
     "Name": "Legacy ASN.1 and X.509 implementation (documentation in progress)",

package/third_party/boringssl/src/util/fipstools/acvp/acvptool/subprocess/subprocess.go

@@ -77,6 +77,10 @@ func NewWithIO(cmd *exec.Cmd, in io.WriteCloser, out io.ReadCloser) *Subprocess
 		"SHA2-384":          &hashPrimitive{"SHA2-384", 48},
 		"SHA2-512":          &hashPrimitive{"SHA2-512", 64},
 		"SHA2-512/256":      &hashPrimitive{"SHA2-512/256", 32},
+		"SHA3-224":          &hashPrimitive{"SHA3-224", 28},
+		"SHA3-256":          &hashPrimitive{"SHA3-256", 32},
+		"SHA3-384":          &hashPrimitive{"SHA3-384", 48},
+		"SHA3-512":          &hashPrimitive{"SHA3-512", 64},
 		"ACVP-AES-ECB":      &blockCipher{"AES", 16, 2, true, false, iterateAES},
 		"ACVP-AES-CBC":      &blockCipher{"AES-CBC", 16, 2, true, true, iterateAESCBC},
 		"ACVP-AES-CBC-CS3":  &blockCipher{"AES-CBC-CS3", 16, 1, false, true, iterateAESCBC},
@@ -93,6 +97,10 @@ func NewWithIO(cmd *exec.Cmd, in io.WriteCloser, out io.ReadCloser) *Subprocess
 		"HMAC-SHA2-384":     &hmacPrimitive{"HMAC-SHA2-384", 48},
 		"HMAC-SHA2-512":     &hmacPrimitive{"HMAC-SHA2-512", 64},
 		"HMAC-SHA2-512/256": &hmacPrimitive{"HMAC-SHA2-512/256", 32},
+		"HMAC-SHA3-224":     &hmacPrimitive{"HMAC-SHA3-224", 28},
+		"HMAC-SHA3-256":     &hmacPrimitive{"HMAC-SHA3-256", 32},
+		"HMAC-SHA3-384":     &hmacPrimitive{"HMAC-SHA3-384", 48},
+		"HMAC-SHA3-512":     &hmacPrimitive{"HMAC-SHA3-512", 64},
 		"ctrDRBG":           &drbg{"ctrDRBG", map[string]bool{"AES-128": true, "AES-192": true, "AES-256": true}},
 		"hmacDRBG":          &drbg{"hmacDRBG", map[string]bool{"SHA-1": true, "SHA2-224": true, "SHA2-256": true, "SHA2-384": true, "SHA2-512": true}},
 		"KDF":               &kdfPrimitive{},

package/third_party/googleurl/AUTHORS

@@ -236,6 +236,7 @@ Claudio DeSouza <claudiomdsjr@gmail.com>
 Clemens Fruhwirth <clemens@endorphin.org>
 Clement Scheelfeldt Skau <clementskau@gmail.com>
 Clinton Staley <clintstaley@gmail.com>
+Cong Zuo <zckevinzc@gmail.com>
 Connor Pearson <cjp822@gmail.com>
 Conrad Irwin <conrad.irwin@gmail.com>
 Craig Schlenter <craig.schlenter@gmail.com>
@@ -269,6 +270,7 @@ Darshan Sen <raisinten@gmail.com>
 Darshini KN <kn.darshini@samsung.com>
 Dave Vandyke <kzar@kzar.co.uk>
 David Benjamin <davidben@mit.edu>
+David Brown <develop.david.brown@gmail.com>
 David Davidovic <david@davidovic.io>
 David Erceg <erceg.david@gmail.com>
 David Fox <david@davidjfox.com>
@@ -296,6 +298,7 @@ Derek Halman <d.halman@gmail.com>
 Devlin Cronin <rdevlin.cronin@gmail.com>
 Dhi Aurrahman <dio@rockybars.com>
 Di Wu <meetwudi@gmail.com>
+Di Zhang <dizhangg@chromium.org>
 Diana Suvorova <diana.suvorova@gmail.com>
 Diego Fernández Santos <agujaydedal@gmail.com>
 Diego Ferreiro Val <elfogris@gmail.com>
@@ -470,6 +473,7 @@ Isaac Reilly <reillyi@amazon.com>
 Ivan Naydonov <samogot@gmail.com>
 Ivan Sham <ivansham@amazon.com>
 Jack Bates <jack@nottheoilrig.com>
+Jacky Hu <flameddd@gmail.com>
 Jacob Clark <jacob.jh.clark@googlemail.com>
 Jacob Mandelson <jacob@mandelson.org>
 Jaehun Lim <ljaehun.lim@samsung.com>
@@ -571,6 +575,7 @@ Johnson Lin <johnson.lin@intel.com>
 Jonathan Frazer <listedegarde@gmail.com>
 Jonathan Garbee <jonathan@garbee.me>
 Jonathan Hacker <jhacker@arcanefour.com>
+Jonathan Johnson <johnsonjonathan593@gmail.com>
 Jonathan Kingston <kingstonmailbox@gmail.com>
 Jonathan Shimonovich <jonathans@talon-sec.com>
 Jongdeok Kim <jongdeok.kim@navercorp.com>
@@ -733,12 +738,14 @@ Manish Chhajer <chhajer.m@samsung.com>
 Manish Jethani <m.jethani@eyeo.com>
 Manojkumar Bhosale <manojkumar.bhosale@imgtec.com>
 Manuel Braun <thembrown@gmail.com>
+Manuel Lagana <manuel.lagana.dev@gmail.com>
 Mao Yujie <maojie0924@gmail.com>
 Mao Yujie <yujie.mao@intel.com>
 Marc des Garets <marc.desgarets@googlemail.com>
 Marcin Wiacek <marcin@mwiacek.com>
 Marco Rodrigues <gothicx@gmail.com>
 Marcos Caceres <marcos@marcosc.com>
+Marek Behún <kabel@kernel.org>
 Mariam Ali <alimariam@noogler.google.com>
 Mario Pistrich <m.pistrich@gmail.com>
 Mario Sanchez Prada <mario.prada@samsung.com>
@@ -936,6 +943,7 @@ Qiang Zeng <zengqiang1@huawei.com>
 Qiankun Miao <qiankun.miao@intel.com>
 Qing Zhang <qing.zhang@intel.com>
 Qingmei Li <qingmei.li@vivo.com>
+Qiyao Yuan <qiyaoyuan@tencent.com>
 Radu Stavila <stavila@adobe.com>
 Radu Velea <radu.velea@intel.com>
 Rafael Antognolli <rafael.antognolli@intel.com>
@@ -975,6 +983,7 @@ Robert Bear Travis <bear.travis@gmail.com>
 Robert Bear Travis <betravis@adobe.com>
 Robert Bradford <robert.bradford@intel.com>
 Robert Goldberg <goldberg@adobe.com>
+Robert Günzler <r@gnzler.io>
 Robert Hogan <robhogan@gmail.com>
 Robert O'Callahan <rocallahan@gmail.com>
 Robert Nagy <robert.nagy@gmail.com>
@@ -1001,6 +1010,7 @@ Ryan Gonzalez <rymg19@gmail.com>
 Ryan Norton <rnorton10@gmail.com>
 Ryan Sleevi <ryan-chromium-dev@sleevi.com>
 Ryan Yoakum <ryoakum@skobalt.com>
+Rye Zhang <ryezhang@tencent.com>
 Ryo Ogawa <negibokken@gmail.com>
 Ryuan Choi <ryuan.choi@samsung.com>
 Saikrishna Arcot <saiarcot895@gmail.com>
@@ -1090,8 +1100,10 @@ Simon Arlott <simon.arlott@gmail.com>
 Simon Jackson <simon.jackson@sonocent.com>
 Simon La Macchia <smacchia@amazon.com>
 Siva Kumar Gunturi <siva.gunturi@samsung.com>
-Sohan Jyoti Ghosh <sohan.jyoti@huawei.com>
-Sohan Jyoti Ghosh <sohan.jyoti@samsung.com>
+Slava Aseev <nullptrnine@gmail.com>
+Sohan Jyoti Ghosh <sohanjg@chromium.org>
+Sohom Datta <sohom.datta@learner.manipal.edu>
+Sohom Datta <dattasohom1@gmail.com>
 Song Fangzhen <songfangzhen@bytedance.com>
 Song YeWen <ffmpeg@gmail.com>
 Sooho Park <sooho1000@gmail.com>
@@ -1174,6 +1186,7 @@ Tim Steiner <twsteiner@gmail.com>
 Timo Gurr <timo.gurr@gmail.com>
 Timo Reimann <ttr314@googlemail.com>
 Timo Witte <timo.witte@gmail.com>
+Timothy Pearson <tpearson@raptorcs.com>
 Ting Shao <ting.shao@intel.com>
 Tobias Lippert <tobias.lippert@fastmail.com>
 Tobias Soppa <tobias@soppa.me>
@@ -1316,6 +1329,7 @@ Zhengkun Li <zhengkli@amazon.com>
 Zhenyu Liang <zhenyu.liang@intel.com>
 Zhenyu Shan <zhenyu.shan@intel.com>
 Zhifei Fang <facetothefate@gmail.com>
+Zhiyuan Ye <zhiyuanye@tencent.com>
 Zhuoyu Qian <zhuoyu.qian@samsung.com>
 Ziran Sun <ziran.sun@samsung.com>
 Zoltan Czirkos <czirkos.zoltan@gmail.com>

package/third_party/googleurl/base/BUILD

@@ -32,6 +32,7 @@ cc_library(
         "functional/invoke.h",
         "functional/not_fn.h",
         "memory/raw_ptr.h",
+        "memory/raw_ptr_exclusion.h",
         "no_destructor.h",
         "ranges/algorithm.h",
         "ranges/functional.h",

package/third_party/googleurl/base/compiler_specific.h

@@ -24,6 +24,13 @@
 #define HAS_CPP_ATTRIBUTE(x) 0
 #endif
 
+// A wrapper around `__has_attribute`, similar to HAS_CPP_ATTRIBUTE.
+#if defined(__has_attribute)
+#define HAS_ATTRIBUTE(x) __has_attribute(x)
+#else
+#define HAS_ATTRIBUTE(x) 0
+#endif
+
 // A wrapper around `__has_builtin`, similar to HAS_CPP_ATTRIBUTE.
 #if defined(__has_builtin)
 #define HAS_BUILTIN(x) __has_builtin(x)
@@ -58,7 +65,7 @@
 // prevent code folding, see NO_CODE_FOLDING() in base/debug/alias.h.
 // Use like:
 //   void NOT_TAIL_CALLED FooBar();
-#if defined(__clang__) && __has_attribute(not_tail_called)
+#if defined(__clang__) && HAS_ATTRIBUTE(not_tail_called)
 #define NOT_TAIL_CALLED __attribute__((not_tail_called))
 #else
 #define NOT_TAIL_CALLED
@@ -126,11 +133,9 @@
 //   __attribute__((format(wprintf, format_param, dots_param)))
 
 // Sanitizers annotations.
-#if defined(__has_attribute)
-#if __has_attribute(no_sanitize)
+#if HAS_ATTRIBUTE(no_sanitize)
 #define NO_SANITIZE(what) __attribute__((no_sanitize(what)))
 #endif
-#endif
 #if !defined(NO_SANITIZE)
 #define NO_SANITIZE(what)
 #endif
@@ -238,7 +243,7 @@
 #endif
 #endif
 
-#if defined(__clang__) && __has_attribute(uninitialized)
+#if defined(__clang__) && HAS_ATTRIBUTE(uninitialized)
 // Attribute "uninitialized" disables -ftrivial-auto-var-init=pattern for
 // the specified variable.
 // Library-wide alternative is
@@ -285,13 +290,9 @@
 // In some cases it's desirable to remove this, e.g. on hot functions, or if
 // we have purposely changed the reference canary.
 #if defined(COMPILER_GCC) || defined(__clang__)
-#if defined(__has_attribute)
-#if __has_attribute(__no_stack_protector__)
+#if HAS_ATTRIBUTE(__no_stack_protector__)
 #define NO_STACK_PROTECTOR __attribute__((__no_stack_protector__))
-#else  // __has_attribute(__no_stack_protector__)
-#define NO_STACK_PROTECTOR __attribute__((__optimize__("-fno-stack-protector")))
-#endif
-#else  // defined(__has_attribute)
+#else
 #define NO_STACK_PROTECTOR __attribute__((__optimize__("-fno-stack-protector")))
 #endif
 #else
@@ -328,7 +329,7 @@ inline constexpr bool AnalyzerAssumeTrue(bool arg) {
 #endif  // defined(__clang_analyzer__)
 
 // Use nomerge attribute to disable optimization of merging multiple same calls.
-#if defined(__clang__) && __has_attribute(nomerge)
+#if defined(__clang__) && HAS_ATTRIBUTE(nomerge)
 #define NOMERGE [[clang::nomerge]]
 #else
 #define NOMERGE
@@ -355,7 +356,7 @@ inline constexpr bool AnalyzerAssumeTrue(bool arg) {
 // See also:
 //   https://clang.llvm.org/docs/AttributeReference.html#trivial-abi
 //   https://libcxx.llvm.org/docs/DesignDocs/UniquePtrTrivialAbi.html
-#if defined(__clang__) && __has_attribute(trivial_abi)
+#if defined(__clang__) && HAS_ATTRIBUTE(trivial_abi)
 #define TRIVIAL_ABI [[clang::trivial_abi]]
 #else
 #define TRIVIAL_ABI
@@ -364,7 +365,7 @@ inline constexpr bool AnalyzerAssumeTrue(bool arg) {
 // Marks a member function as reinitializing a moved-from variable.
 // See also
 // https://clang.llvm.org/extra/clang-tidy/checks/bugprone-use-after-move.html#reinitialization
-#if defined(__clang__) && __has_attribute(reinitializes)
+#if defined(__clang__) && HAS_ATTRIBUTE(reinitializes)
 #define REINITIALIZES_AFTER_MOVE [[clang::reinitializes]]
 #else
 #define REINITIALIZES_AFTER_MOVE
@@ -373,11 +374,9 @@ inline constexpr bool AnalyzerAssumeTrue(bool arg) {
 // Requires constant initialization. See constinit in C++20. Allows to rely on a
 // variable being initialized before execution, and not requiring a global
 // constructor.
-#if defined(__has_attribute)
-#if __has_attribute(require_constant_initialization)
+#if HAS_ATTRIBUTE(require_constant_initialization)
 #define CONSTINIT __attribute__((require_constant_initialization))
 #endif
-#endif
 #if !defined(CONSTINIT)
 #define CONSTINIT
 #endif

package/third_party/googleurl/base/containers/contiguous_iterator.h

@@ -18,7 +18,10 @@ namespace gurl_base {
 namespace internal {
 
 template <typename T>
-struct PointsToObject : std::is_object<iter_value_t<T>> {};
+struct PointsToObject : std::true_type {};
+// std::iter_value_t is not defined for `T*` where T is not an object type.
+template <typename T>
+struct PointsToObject<T*> : std::is_object<T> {};
 
 // A pointer is a contiguous iterator.
 // Reference: https://wg21.link/iterator.traits#5
@@ -74,15 +77,16 @@ struct IsCheckedContiguousIter
 
 // Check that the iterator points to an actual object, and is one of the
 // iterator types mentioned above.
+template <typename T, bool B = PointsToObject<T>::value>
+struct IsContiguousIteratorImpl : std::false_type {};
 template <typename T>
-struct IsContiguousIteratorImpl
-    : std::conjunction<PointsToObject<T>,
-                       std::disjunction<IsPointer<T>,
-                                        IsStringIter<T>,
-                                        IsArrayIter<T>,
-                                        IsVectorIter<T>,
-                                        IsValueArrayIter<T>,
-                                        IsCheckedContiguousIter<T>>> {};
+struct IsContiguousIteratorImpl<T, true>
+    : std::disjunction<IsPointer<T>,
+                       IsStringIter<T>,
+                       IsArrayIter<T>,
+                       IsVectorIter<T>,
+                       IsValueArrayIter<T>,
+                       IsCheckedContiguousIter<T>> {};
 
 }  // namespace internal
 

package/third_party/googleurl/base/containers/span.h

@@ -7,7 +7,6 @@
 
 #include <stddef.h>
 
-#include <algorithm>
 #include <array>
 #include <iterator>
 #include <limits>
@@ -470,10 +469,19 @@ as_writable_bytes(span<T, X> s) noexcept {
 }
 
 // Type-deducing helpers for constructing a span.
-template <int&... ExplicitArgumentBarrier, typename It, typename EndOrSize>
-constexpr auto make_span(It it, EndOrSize end_or_size) noexcept {
+template <int&... ExplicitArgumentBarrier, typename It>
+constexpr auto make_span(It it, size_t size) noexcept {
   using T = std::remove_reference_t<iter_reference_t<It>>;
-  return span<T>(it, end_or_size);
+  return span<T>(it, size);
+}
+
+template <int&... ExplicitArgumentBarrier,
+          typename It,
+          typename End,
+          typename = std::enable_if_t<!std::is_convertible_v<End, size_t>>>
+constexpr auto make_span(It it, End end) noexcept {
+  using T = std::remove_reference_t<iter_reference_t<It>>;
+  return span<T>(it, end);
 }
 
 // make_span utility function that deduces both the span's value_type and extent
@@ -488,7 +496,7 @@ constexpr auto make_span(Container&& container) noexcept {
   return span<T, Extent::value>(std::forward<Container>(container));
 }
 
-// make_span utility function that allows callers to explicit specify the span's
+// make_span utility functions that allow callers to explicit specify the span's
 // extent, the value_type is deduced automatically. This is useful when passing
 // a dynamically sized container to a method expecting static spans, when the
 // container is known to have the correct size.
@@ -496,13 +504,20 @@ constexpr auto make_span(Container&& container) noexcept {
 // Note: This will GURL_CHECK that N indeed matches size(container).
 //
 // Usage: auto static_span = gurl_base::make_span<N>(...);
+template <size_t N, int&... ExplicitArgumentBarrier, typename It>
+constexpr auto make_span(It it, size_t size) noexcept {
+  using T = std::remove_reference_t<iter_reference_t<It>>;
+  return span<T, N>(it, size);
+}
+
 template <size_t N,
           int&... ExplicitArgumentBarrier,
           typename It,
-          typename EndOrSize>
-constexpr auto make_span(It it, EndOrSize end_or_size) noexcept {
+          typename End,
+          typename = std::enable_if_t<!std::is_convertible_v<End, size_t>>>
+constexpr auto make_span(It it, End end) noexcept {
   using T = std::remove_reference_t<iter_reference_t<It>>;
-  return span<T, N>(it, end_or_size);
+  return span<T, N>(it, end);
 }
 
 template <size_t N, int&... ExplicitArgumentBarrier, typename Container>

package/third_party/googleurl/base/memory/raw_ptr.h

@@ -36,21 +36,11 @@
 #if defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
 #include "base/allocator/partition_allocator/partition_tag.h"
 #include "base/allocator/partition_allocator/tagging.h"
+#include "polyfills/base/check_op.h"
 #endif  // defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
 
 #if BUILDFLAG(IS_WIN)
-#include <windows.h>
-#endif
-
-#if defined(OFFICIAL_BUILD)
-// The annotation changed compiler output and increased binary size so disable
-// for official builds.
-// TODO(crbug.com/1320670): Remove when issue is resolved.
-#define RAW_PTR_EXCLUSION
-#else
-// Marks a field as excluded from the raw_ptr usage enforcement clang plugin.
-// Example: RAW_PTR_EXCLUSION Foo* foo_;
-#define RAW_PTR_EXCLUSION __attribute__((annotate("raw_ptr_exclusion")))
+#include "base/win/win_handle_types.h"
 #endif
 
 namespace cc {
@@ -114,7 +104,7 @@ struct RawPtrNoOpImpl {
     return wrapped_ptr;
   }
 
-  // Advance the wrapped pointer by |delta| bytes.
+  // Advance the wrapped pointer by `delta_elems`.
   template <typename T>
   static ALWAYS_INLINE T* Advance(T* wrapped_ptr, ptrdiff_t delta_elems) {
     return wrapped_ptr + delta_elems;
@@ -161,8 +151,8 @@ struct MTECheckedPtrImplPartitionAllocSupport {
     // allocated by PartitionAlloc, from normal buckets pool.
     //
     // TODO(crbug.com/1307514): Allow direct-map buckets.
-    return IsManagedByPartitionAlloc(as_uintptr) &&
-           IsManagedByNormalBuckets(as_uintptr);
+    return partition_alloc::IsManagedByPartitionAlloc(as_uintptr) &&
+           partition_alloc::internal::IsManagedByNormalBuckets(as_uintptr);
   }
 
   // Returns pointer to the tag that protects are pointed by |ptr|.
@@ -255,10 +245,10 @@ struct MTECheckedPtrImpl {
     return static_cast<To*>(wrapped_ptr);
   }
 
-  // Advance the wrapped pointer by |delta| bytes.
+  // Advance the wrapped pointer by `delta_elems`.
   template <typename T>
-  static ALWAYS_INLINE T* Advance(T* wrapped_ptr, ptrdiff_t delta_elem) {
-    return wrapped_ptr + delta_elem;
+  static ALWAYS_INLINE T* Advance(T* wrapped_ptr, ptrdiff_t delta_elems) {
+    return wrapped_ptr + delta_elems;
   }
 
   // Returns a copy of a wrapped pointer, without making an assertion
@@ -305,7 +295,8 @@ struct BackupRefPtrImpl {
 
   static ALWAYS_INLINE bool IsSupportedAndNotNull(uintptr_t address) {
     // This covers the nullptr case, as address 0 is never in GigaCage.
-    bool is_in_brp_pool = IsManagedByPartitionAllocBRPPool(address);
+    bool is_in_brp_pool =
+        partition_alloc::IsManagedByPartitionAllocBRPPool(address);
 
     // There are many situations where the compiler can prove that
     // ReleaseWrappedPtr is called on a value that is always nullptr, but the
@@ -366,7 +357,8 @@ struct BackupRefPtrImpl {
     }
 #if !defined(PA_HAS_64_BITS_POINTERS)
     else {
-      AddressPoolManagerBitmap::BanSuperPageFromBRPPool(address);
+      partition_alloc::internal::AddressPoolManagerBitmap::
+          BanSuperPageFromBRPPool(address);
     }
 #endif
 
@@ -430,15 +422,15 @@ struct BackupRefPtrImpl {
     return wrapped_ptr;
   }
 
-  // Advance the wrapped pointer by |delta| bytes.
+  // Advance the wrapped pointer by `delta_elems`.
   template <typename T>
-  static ALWAYS_INLINE T* Advance(T* wrapped_ptr, ptrdiff_t delta_elem) {
+  static ALWAYS_INLINE T* Advance(T* wrapped_ptr, ptrdiff_t delta_elems) {
 #if GURL_DCHECK_IS_ON() || BUILDFLAG(ENABLE_BACKUP_REF_PTR_SLOW_CHECKS)
     uintptr_t address = reinterpret_cast<uintptr_t>(wrapped_ptr);
     if (IsSupportedAndNotNull(address))
-      GURL_CHECK(IsValidDelta(address, delta_elem * sizeof(T)));
+      GURL_CHECK(IsValidDelta(address, delta_elems * sizeof(T)));
 #endif
-    T* new_wrapped_ptr = WrapRawPtr(wrapped_ptr + delta_elem);
+    T* new_wrapped_ptr = WrapRawPtr(wrapped_ptr + delta_elems);
     ReleaseWrappedPtr(wrapped_ptr);
     return new_wrapped_ptr;
   }
@@ -517,7 +509,7 @@ struct AsanBackupRefPtrImpl {
     return wrapped_ptr;
   }
 
-  // Advance the wrapped pointer by |delta| bytes.
+  // Advance the wrapped pointer by `delta_elems`.
   template <typename T>
   static ALWAYS_INLINE T* Advance(T* wrapped_ptr, ptrdiff_t delta_elems) {
     return wrapped_ptr + delta_elems;

package/third_party/googleurl/base/memory/raw_ptr_exclusion.h

@@ -0,0 +1,21 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_MEMORY_RAW_PTR_EXCLUSION_H_
+#define BASE_MEMORY_RAW_PTR_EXCLUSION_H_
+
+#include "build/build_config.h"
+
+#if defined(OFFICIAL_BUILD)
+// The annotation changed compiler output and increased binary size so disable
+// for official builds.
+// TODO(crbug.com/1320670): Remove when issue is resolved.
+#define RAW_PTR_EXCLUSION
+#else
+// Marks a field as excluded from the raw_ptr usage enforcement clang plugin.
+// Example: RAW_PTR_EXCLUSION Foo* foo_;
+#define RAW_PTR_EXCLUSION __attribute__((annotate("raw_ptr_exclusion")))
+#endif
+
+#endif  // BASE_MEMORY_RAW_PTR_EXCLUSION_H_

package/third_party/googleurl/base/strings/escape.cc

@@ -7,6 +7,8 @@
 #include <ostream>
 
 #include "polyfills/base/check_op.h"
+#include "base/feature_list.h"
+#include "base/features.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversion_utils.h"
@@ -210,7 +212,7 @@ bool UnescapeUnsignedByteAtIndex(StringPiece escaped_text,
 // |escaped_text| that corresponds to the unescaped character.
 bool UnescapeUTF8CharacterAtIndex(StringPiece escaped_text,
                                   size_t index,
-                                  uint32_t* code_point_out,
+                                  base_icu::UChar32* code_point_out,
                                   std::string* unescaped_out) {
   GURL_DCHECK(unescaped_out->empty());
 
@@ -404,7 +406,7 @@ std::string UnescapeURLWithAdjustmentsImpl(
   // Locations of adjusted text.
   for (size_t i = 0, max = escaped_text.size(); i < max;) {
     // Try to unescape the character.
-    uint32_t code_point;
+    base_icu::UChar32 code_point;
     std::string unescaped;
     if (!UnescapeUTF8CharacterAtIndex(escaped_text, i, &code_point,
                                       &unescaped)) {
@@ -540,6 +542,16 @@ std::string UnescapeBinaryURLComponent(StringPiece escaped_text,
   GURL_DCHECK(!(rules &
            ~(UnescapeRule::NORMAL | UnescapeRule::REPLACE_PLUS_WITH_SPACE)));
 
+  // If there are no '%' characters in the string, there will be nothing to
+  // unescape, so we can take the fast path.
+  if (gurl_base::FeatureList::IsEnabled(features::kOptimizeDataUrls) &&
+      escaped_text.find('%') == StringPiece::npos) {
+    std::string unescaped_text(escaped_text);
+    if (rules & UnescapeRule::REPLACE_PLUS_WITH_SPACE)
+      std::replace(unescaped_text.begin(), unescaped_text.end(), '+', ' ');
+    return unescaped_text;
+  }
+
   std::string unescaped_text;
 
   // The output of the unescaping is always smaller than the input, so we can

package/third_party/googleurl/base/strings/safe_sprintf.h

@@ -175,7 +175,7 @@ struct Arg {
     integer.width = sizeof(long long);
   }
   Arg(unsigned long long j) : type(UINT) {
-    integer.i = j;
+    integer.i = static_cast<int64_t>(j);
     integer.width = sizeof(long long);
   }
 

package/third_party/googleurl/base/strings/string_number_conversions.cc

@@ -155,19 +155,21 @@ bool HexStringToUInt64(StringPiece input, uint64_t* output) {
 
 bool HexStringToBytes(StringPiece input, std::vector<uint8_t>* output) {
   GURL_DCHECK(output->empty());
-  return internal::HexStringToByteContainer(input, std::back_inserter(*output));
+  return internal::HexStringToByteContainer<uint8_t>(
+      input, std::back_inserter(*output));
 }
 
 bool HexStringToString(StringPiece input, std::string* output) {
   GURL_DCHECK(output->empty());
-  return internal::HexStringToByteContainer(input, std::back_inserter(*output));
+  return internal::HexStringToByteContainer<char>(input,
+                                                  std::back_inserter(*output));
 }
 
 bool HexStringToSpan(StringPiece input, gurl_base::span<uint8_t> output) {
   if (input.size() / 2 != output.size())
     return false;
 
-  return internal::HexStringToByteContainer(input, output.begin());
+  return internal::HexStringToByteContainer<uint8_t>(input, output.begin());
 }
 
 }  // namespace base