Update googleurl to the latest version
This updates googleurl to the revision
21069c2dfa90d5bdd123c0d0d202dfc61f5f6920, Wed Jul 8 16:20:09 2020 +0000.
diff --git a/AUTHORS b/AUTHORS
index a8d90ac..48cfe49 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -37,6 +37,7 @@
Ajay Berwal <a.berwal@samsung.com>
Ajay Berwal <ajay.berwal@samsung.com>
Ajith Kumar V <ajith.v@samsung.com>
+Akos Kiss <akiss@inf.u-szeged.hu>
Aku Kotkavuo <a.kotkavuo@partner.samsung.com>
Aldo Culquicondor <alculquicondor@gmail.com>
Aleksandar Stojiljkovic <aleksandar.stojiljkovic@intel.com>
@@ -76,6 +77,7 @@
anatoly techtonik <techtonik@gmail.com>
Ancil George <ancilgeorge@samsung.com>
Andra Paraschiv <andra.paraschiv@intel.com>
+Andreas Papacharalampous <andreas@apap04.com>
Andrei Borza <andrei.borza@gmail.com>
Andrei Parvu <andrei.prv@gmail.com>
Andrei Parvu <parvu@adobe.com>
@@ -86,6 +88,7 @@
Andrew Jorgensen <ajorgens@amazon.com>
Andrew MacPherson <andrew.macpherson@soundtrap.com>
Andrew Tulloch <andrew@tullo.ch>
+Andriy Rysin <arysin@gmail.com>
Anish Patankar <anish.p@samsung.com>
Ankit Kumar <ankit2.kumar@samsung.com>
Ankur Verma <ankur1.verma@samsung.com>
@@ -93,6 +96,7 @@
Anne Kao <annekao94@gmail.com>
Anssi Hannula <anssi.hannula@iki.fi>
Anthony Halliday <anth.halliday12@gmail.com>
+Anton Bershanskiy <bershanskiy@pm.me>
Anton Obzhirov <a.obzhirov@samsung.com>
Antonin Hildebrand <antonin.hildebrand@gmail.com>
Antonio Gomes <a1.gomes@sisa.samsung.com>
@@ -147,6 +151,7 @@
Brian Luft <brian@electroly.com>
Brian Merrell, Novell Inc. <bgmerrell@gmail.com>
Brian Yip <itsbriany@gmail.com>
+Brook Hong <hzgmaxwell@gmail.com>
Bruno Calvignac <bruno@flock.com>
Bruno de Oliveira Abinader <brunoabinader@gmail.com>
Bruno Roy <brusi_roy@hotmail.com>
@@ -164,6 +169,7 @@
Catalin Badea <badea@adobe.com>
Cathie Chen <cathiechen@tencent.com>
Cem Kocagil <cem.kocagil@gmail.com>
+Cezary Kułakowski <cezary.kulakowski@gmail.com>
Chakshu Ahuja <chakshu.a@samsung.com>
Chamal De Silva <chamalsl@yahoo.com>
Chandan Padhi <c.padhi@samsung.com>
@@ -179,6 +185,7 @@
Chansik Yun <chansik.yun@gmail.com>
Chaobin Zhang <zhchbin@gmail.com>
Charles Vaughn <cvaughn@gmail.com>
+Cheng Zhao <zcbenz@gmail.com>
Choongwoo Han <cwhan.tunz@gmail.com>
Chris Greene <cwgreene@amazon.com>
Chris Harrelson <chrishtr@gmail.com>
@@ -188,6 +195,7 @@
Chris Vasselli <clindsay@gmail.com>
Christophe Dumez <ch.dumez@samsung.com>
Christopher Dale <chrelad@gmail.com>
+Chunbo Hua <chunbo.hua@intel.com>
Claudio DeSouza <claudiomdsjr@gmail.com>
Clemens Fruhwirth <clemens@endorphin.org>
Clement Scheelfeldt Skau <clementskau@gmail.com>
@@ -196,6 +204,7 @@
Conrad Irwin <conrad.irwin@gmail.com>
Craig Schlenter <craig.schlenter@gmail.com>
Csaba Osztrogonác <ossy.szeged@gmail.com>
+Cynthia Revström <me@cynthia.re>
Daegyu Lee <na7jun8gi@gmail.com>
Dai Chunyang <chunyang.dai@intel.com>
Daiwei Li <daiweili@suitabletech.com>
@@ -223,6 +232,8 @@
David Erceg <erceg.david@gmail.com>
David Fox <david@davidjfox.com>
David Futcher <david.mike.futcher@gmail.com>
+David Jin <davidjin@amazon.com>
+David Lechner <david@pybricks.com>
David Leen <davileen@amazon.com>
David Manouchehri <david@davidmanouchehri.com>
David McAllister <mcdavid@amazon.com>
@@ -265,6 +276,7 @@
Eduardo Lima (Etrunko) <eduardo.lima@intel.com>
Edward Baker <edward.baker@intel.com>
Edward Crossman <tedoc2000@gmail.com>
+Edward Trist <edwardtrist@gmail.com>
Eero Häkkinen <e.hakkinen@samsung.com>
Eero Häkkinen <eero.hakkinen@intel.com>
Egor Starkov <egor.starkov@samsung.com>
@@ -299,6 +311,7 @@
Francois Rauch <leopardb@gmail.com>
Frankie Dintino <fdintino@theatlantic.com>
Franklin Ta <fta2012@gmail.com>
+Fred Ranking <luliang14@huawei.com>
Frédéric Jacob <frederic.jacob.78@gmail.com>
Frédéric Wang <fred.wang@free.fr>
Fu Junwei <junwei.fu@intel.com>
@@ -425,6 +438,7 @@
Jeffrey C <jeffreyca16@gmail.com>
Jeongeun Kim <je_julie.kim@samsung.com>
Jeongmin Kim <kimwjdalsl@gmail.com>
+Jeongwoo Park <jwoo.park@navercorp.com>
Jeongwoo Park <skeksk91@gmail.com>
Jeremy Noring <jnoring@hirevue.com>
Jeremy Spiegel <jeremysspiegel@gmail.com>
@@ -442,6 +456,7 @@
Jiawei Shao <jiawei.shao@intel.com>
Jiaxun Wei <leuisken@gmail.com>
Jiaxun Yang <jiaxun.yang@flygoat.com>
+Jidong Qin <qinjidong@qianxin.com>
Jie Chen <jie.a.chen@intel.com>
Jihan Chao <jihan@bluejeans.com>
Jihoon Chung <j.c@navercorp.com>
@@ -457,6 +472,7 @@
Jingyi Wei <wjywbs@gmail.com>
Jinho Bang <jinho.bang@samsung.com>
Jinsong Fan <fanjinsong@sogou-inc.com>
+Jinsong Fan <jinsong.van@gmail.com>
Jinwoo Song <jinwoo7.song@samsung.com>
Jinyoung Hur <hurims@gmail.com>
Jitendra Kumar Sahoo <jitendra.ks@samsung.com>
@@ -525,6 +541,7 @@
Kaustubh Atrawalkar <kaustubh.ra@gmail.com>
Ke He <ke.he@intel.com>
Keene Pan <keenepan@linpus.com>
+Keita Suzuki <keitasuzuki.park@gmail.com>
Keita Yoshimoto <y073k3@gmail.com>
Keith Chen <keitchen@amazon.com>
Kenneth Rohde Christiansen <kenneth.r.christiansen@intel.com>
@@ -565,6 +582,7 @@
Kyungtae Kim <ktf.kim@samsung.com>
Kyungyoung Heo <bbvch13531@gmail.com>
Lalit Chandivade <lalit.chandivade@einfochips.com>
+Lam Lu <lamlu@amazon.com>
Laszlo Gombos <l.gombos@samsung.com>
Laszlo Radanyi <bekkra@gmail.com>
Lauren Yeun Kim <lauren.yeun.kim@gmail.com>
@@ -572,6 +590,7 @@
Lavar Askew <open.hyperion@gmail.com>
Legend Lee <guanxian.li@intel.com>
Leith Bade <leith@leithalweapon.geek.nz>
+Lei Li <lli.kernel.kvm@gmail.com>
Lenny Khazan <lenny.khazan@gmail.com>
Leo Wolf <jclw@ymail.com>
Leon Han <leon.han@intel.com>
@@ -579,6 +598,7 @@
Li Yin <li.yin@intel.com>
Lidwine Genevet <lgenevet@cisco.com>
Lin Sun <lin.sun@intel.com>
+Lingqi Chi <someway.bit@gmail.com>
Lingyun Cai <lingyun.cai@intel.com>
Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Lizhi Fan <lizhi.fan@samsung.com>
@@ -589,6 +609,7 @@
Lucie Brozkova <lucinka.brozkova@gmail.com>
Luiz Von Dentz <luiz.von.dentz@intel.com>
Luka Dojcilovic <l.dojcilovic@gmail.com>
+Lukasz Krakowiak <lukasz.krakowiak@mobica.com>
Luke Inman-Semerau <luke.semerau@gmail.com>
Luke Zarko <lukezarko@gmail.com>
Luoxi Pan <l.panpax@gmail.com>
@@ -616,6 +637,7 @@
Mark Seaborn <mrs@mythic-beasts.com>
Martijn Croonen <martijn@martijnc.be>
Martin Bednorz <m.s.bednorz@gmail.com>
+Martin Persson <mnpn03@gmail.com>
Martin Rogalla <martin@martinrogalla.com>
Martina Kollarova <martina.kollarova@intel.com>
Masahiro Yado <yado.masa@gmail.com>
@@ -625,12 +647,14 @@
Mathias Bynens <mathias@qiwi.be>
Mathieu Meisser <mmeisser@logitech.com>
Matt Arpidone <mma.public@gmail.com>
+Matt Fysh <mattfysh@gmail.com>
Matt Strum <mstrum@amazon.com>
Matt Zeunert <matt@mostlystatic.com>
Matthew Bauer <mjbauer95@gmail.com>
Matthew Demarest <demarem@amazon.com>
Matthew Robertson <matthewrobertson03@gmail.com>
Matthew Turk <matthewturk@gmail.com>
+Matthew Webb <mwebbmwebb@gmail.com>
Matthew Willis <appamatto@gmail.com>
Matthias Reitinger <reimarvin@gmail.com>
Matthieu Rigolot <matthieu.rigolot@gmail.com>
@@ -643,6 +667,7 @@
Md Jobed Hossain <jrony15@gmail.com>
Md Sami Uddin <md.sami@samsung.com>
Michael Cirone <mikecirone@gmail.com>
+Michael Constant <mconst@gmail.com>
Michael Forney <mforney@mforney.org>
Michael Gilbert <floppymaster@gmail.com>
Michael Lopez <lopes92290@gmail.com>
@@ -704,6 +729,7 @@
Nils Schneider <nils@nilsschneider.net>
Ningxin Hu <ningxin.hu@intel.com>
Nitish Mehrotra <nitish.m@samsung.com>
+Noam Rosenthal <noam.j.rosenthal@gmail.com>
Noj Vek <nojvek@gmail.com>
Nolan Cao <nolan.robin.cao@gmail.com>
Oleksii Kadurin <ovkadurin@gmail.com>
@@ -812,11 +838,13 @@
Rosen Dash <nqk836@motorola.com>
Rosen Dash <rosen.dash@gmail.com>
Ross Kirsling <rkirsling@gmail.com>
+Ross Wollman <ross.wollman@gmail.com>
ruben <chromium@hybridsource.org>
Ruben Bridgewater <ruben@bridgewater.de>
Ruben Terrazas <rubentopo@gmail.com>
Rufus Hamade <rufus.hamade@imgtec.com>
Ruiyi Luo <luoruiyi2008@gmail.com>
+Russell Davis <russell.davis@gmail.com>
Ryan Ackley <ryanackley@gmail.com>
Ryan Norton <rnorton10@gmail.com>
Ryan Sleevi <ryan-chromium-dev@sleevi.com>
@@ -833,6 +861,7 @@
Sanghyun Park <sh919.park@samsung.com>
Sanghyup Lee <sh53.lee@samsung.com>
Sangjoon Je <htamop@gmail.com>
+Sangseok Jang <sangseok.jang@gmail.com>
Sangseok Jang <sangseok.jang@navercorp.com>
Sangwoo Ko <sangwoo.ko@navercorp.com>
Sangwoo Ko <sangwoo108@gmail.com>
@@ -840,6 +869,7 @@
Sanjoy Pal <sanjoy.pal@samsung.com>
Sanne Wouda <sanne.wouda@gmail.com>
Santosh Mahto <samahto@cisco.com>
+Sarah Jochum <smjochum@gmail.com>
Sarath Singapati <s.singapati@gmail.com>
Sarath Singapati <s.singapati@samsung.com>
Sarath Singapati <sarath.singapati@huawei.com>
@@ -910,6 +940,7 @@
Staphany Park <stapark008@gmail.com>
Stephan Hartmann <stha09@googlemail.com>
Stephen Searles <stephen.searles@gmail.com>
+Stephen Sigwart <ssigwart@gmail.com>
Steve Sanders <steve@zanderz.com>
Steven Pennington <spenn@engr.uvic.ca>
Steven Roussey <sroussey@gmail.com>
@@ -926,6 +957,7 @@
Sungmann Cho <sungmann.cho@navercorp.com>
Sunil Ratnu <sunil.ratnu@samsung.com>
Sunitha Srivatsa <srivats@amazon.com>
+Sushma Venkatesh Reddy <sushma.venkatesh.reddy@intel.com>
Suvanjan Mukherjee <suvanjanmukherjee@gmail.com>
Suyambulingam R M <suyambu.rm@samsung.com>
Suyash Sengar <suyash.s@samsung.com>
@@ -997,6 +1029,7 @@
Vivek Galatage <vivek.vg@samsung.com>
Volker Sorge <volker.sorge@gmail.com>
Waihung Fu <fufranci@amazon.com>
+Wojciech Bielawski <wojciech.bielawski@gmail.com>
Wanming Lin <wanming.lin@intel.com>
Wei Li <wei.c.li@intel.com>
Wenxiang Qian <leonwxqian@gmail.com>
@@ -1007,6 +1040,7 @@
Will Hirsch <chromium@willhirsch.co.uk>
Will Shackleton <w.shackleton@gmail.com>
William Xie <william.xie@intel.com>
+Winston Chen <winston.c1@samsung.com>
Xiang Long <xiang.long@intel.com>
Xiangze Zhang <xiangze.zhang@intel.com>
Xiaofeng Zhang <xiaofeng.zhang@intel.com>
@@ -1019,6 +1053,7 @@
Xu Samuel <samuel.xu@intel.com>
Xu Xing <xing.xu@intel.com>
Xuefei Ren <xrenishere@gmail.com>
+Xuehui Xie <xuehui.xxh@alibaba-inc.com>
Xueqing Huang <huangxueqing@xiaomi.com>
Xun Sun <xun.sun@intel.com>
Xunran Ding <xunran.ding@samsung.com>
@@ -1076,10 +1111,13 @@
Zhifei Fang <facetothefate@gmail.com>
Zhuoyu Qian <zhuoyu.qian@samsung.com>
Ziran Sun <ziran.sun@samsung.com>
+Zoltan Czirkos <czirkos.zoltan@gmail.com>
Zoltan Herczeg <zherczeg.u-szeged@partner.samsung.com>
Zoltan Kuscsik <zoltan.kuscsik@linaro.org>
Zsolt Borbely <zsborbely.u-szeged@partner.samsung.com>
方觉 (Fang Jue) <fangjue23303@gmail.com>
+Julian Geppert <spctstr@gmail.com>
+Jiadong Chen <chenjiadong@huawei.com>
# END individuals section.
# BEGIN organizations section.
@@ -1117,6 +1155,7 @@
Mediatek <*@mediatek.com>
Microsoft <*@microsoft.com>
MIPS Technologies, Inc. <*@mips.com>
+Mobica Limited <*@mobica.com>
Mozilla Corporation <*@mozilla.com>
Neverware Inc. <*@neverware.com>
NIKE, Inc. <*@nike.com>
@@ -1129,6 +1168,7 @@
Seznam.cz, a.s. <*@firma.seznam.cz>
Slack Technologies Inc. <*@slack-corp.com>
Spotify AB <*@spotify.com>
+Synaptics <*@synaptics.com>
Tableau Software <*@tableau.com>
TeamSpeak Systems GmbH <*@teamspeak.com>
The Chromium Authors <*@chromium.org>
diff --git a/base/BUILD b/base/BUILD
index efad13f..74b721d 100644
--- a/base/BUILD
+++ b/base/BUILD
@@ -7,6 +7,9 @@
name = "base",
hdrs = [
"compiler_specific.h",
+ "containers/checked_iterators.h",
+ "containers/span.h",
+ "containers/util.h",
"debug/leak_annotations.h",
"macros.h",
"no_destructor.h",
diff --git a/base/compiler_specific.h b/base/compiler_specific.h
index 2962537..0cd36dc 100644
--- a/base/compiler_specific.h
+++ b/base/compiler_specific.h
@@ -47,6 +47,20 @@
#define ALWAYS_INLINE inline
#endif
+// Annotate a function indicating it should never be tail called. Useful to make
+// sure callers of the annotated function are never omitted from call-stacks.
+// To provide the complementary behavior (prevent the annotated function from
+// being omitted) look at NOINLINE. Also note that this doesn't prevent code
+// folding of multiple identical caller functions into a single signature. To
+// prevent code folding, see gurl_base::debug::Alias.
+// Use like:
+// void NOT_TAIL_CALLED FooBar();
+#if defined(__clang__) && __has_attribute(not_tail_called)
+#define NOT_TAIL_CALLED __attribute__((not_tail_called))
+#else
+#define NOT_TAIL_CALLED
+#endif
+
// Specify memory alignment for structs, classes, etc.
// Use like:
// class ALIGNAS(16) MyClass { ... }
@@ -247,4 +261,35 @@
#define STACK_UNINITIALIZED
#endif
+// The ANALYZER_ASSUME_TRUE(bool arg) macro adds compiler-specific hints
+// to Clang which control what code paths are statically analyzed,
+// and is meant to be used in conjunction with assert & assert-like functions.
+// The expression is passed straight through if analysis isn't enabled.
+//
+// ANALYZER_SKIP_THIS_PATH() suppresses static analysis for the current
+// codepath and any other branching codepaths that might follow.
+#if defined(__clang_analyzer__)
+
+inline constexpr bool AnalyzerNoReturn() __attribute__((analyzer_noreturn)) {
+ return false;
+}
+
+inline constexpr bool AnalyzerAssumeTrue(bool arg) {
+ // AnalyzerNoReturn() is invoked and analysis is terminated if |arg| is
+ // false.
+ return arg || AnalyzerNoReturn();
+}
+
+#define ANALYZER_ASSUME_TRUE(arg) ::AnalyzerAssumeTrue(!!(arg))
+#define ANALYZER_SKIP_THIS_PATH() static_cast<void>(::AnalyzerNoReturn())
+#define ANALYZER_ALLOW_UNUSED(var) static_cast<void>(var);
+
+#else // !defined(__clang_analyzer__)
+
+#define ANALYZER_ASSUME_TRUE(arg) (arg)
+#define ANALYZER_SKIP_THIS_PATH()
+#define ANALYZER_ALLOW_UNUSED(var) static_cast<void>(var);
+
+#endif // defined(__clang_analyzer__)
+
#endif // BASE_COMPILER_SPECIFIC_H_
diff --git a/base/containers/checked_iterators.h b/base/containers/checked_iterators.h
new file mode 100644
index 0000000..30c35bd
--- /dev/null
+++ b/base/containers/checked_iterators.h
@@ -0,0 +1,272 @@
+// Copyright 2018 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_CONTAINERS_CHECKED_ITERATORS_H_
+#define BASE_CONTAINERS_CHECKED_ITERATORS_H_
+
+#include <iterator>
+#include <memory>
+#include <type_traits>
+
+#include "polyfills/base/check_op.h"
+#include "base/containers/util.h"
+
+namespace gurl_base {
+
+template <typename T>
+class CheckedContiguousIterator {
+ public:
+ using difference_type = std::ptrdiff_t;
+ using value_type = std::remove_cv_t<T>;
+ using pointer = T*;
+ using reference = T&;
+ using iterator_category = std::random_access_iterator_tag;
+
+ // Required for converting constructor below.
+ template <typename U>
+ friend class CheckedContiguousIterator;
+
+ constexpr CheckedContiguousIterator() = default;
+
+#if defined(_LIBCPP_VERSION)
+ // The following using declaration, single argument implicit constructor and
+ // friended `__unwrap_iter` overload are required to use an optimized code
+ // path when using a CheckedContiguousIterator with libc++ algorithms such as
+ // std::copy(first, last, result), std::copy_backward(first, last, result),
+ // std::move(first, last, result) and std::move_backward(first, last, result).
+ //
+ // Each of these algorithms dispatches to a std::memmove if this is safe to do
+ // so, i.e. when all of `first`, `last` and `result` are iterators over
+ // contiguous storage of the same type modulo const qualifiers.
+ //
+ // libc++ implements this for its contiguous iterators by invoking the
+ // unqualified __unwrap_iter, which returns the underlying pointer for
+ // iterators over std::vector and std::string, and returns the original
+ // iterator otherwise.
+ //
+ // Thus in order to opt into this optimization for CCI, we need to provide our
+ // own __unwrap_iter, returning the underlying raw pointer if it is safe to do
+ // so.
+ //
+ // Furthermore, considering that std::copy is implemented as follows, the
+ // return type of __unwrap_iter(CCI) needs to be convertible to CCI, which is
+ // why an appropriate implicit single argument constructor is provided for the
+ // optimized case:
+ //
+ // template <class InIter, class OutIter>
+ // OutIter copy(InIter first, InIter last, OutIter result) {
+ // return __copy(__unwrap_iter(first), __unwrap_iter(last),
+ // __unwrap_iter(result));
+ // }
+ //
+ // Unoptimized __copy() signature:
+ // template <class InIter, class OutIter>
+ // OutIter __copy(InIter first, InIter last, OutIter result);
+ //
+ // Optimized __copy() signature:
+ // template <class T, class U>
+ // U* __copy(T* first, T* last, U* result);
+ //
+ // Finally, this single argument constructor sets all internal fields to the
+ // passed in pointer. This allows the resulting CCI to be used in other
+ // optimized calls to std::copy (or std::move, std::copy_backward,
+ // std::move_backward). However, it should not be used otherwise, since
+ // invoking any of its public API will result in a GURL_CHECK failure. This also
+ // means that callers should never use the single argument constructor
+ // directly.
+ template <typename U>
+ using PtrIfSafeToMemmove = std::enable_if_t<
+ std::is_trivially_copy_assignable<std::remove_const_t<U>>::value,
+ U*>;
+
+ template <int&... ExplicitArgumentBarrier, typename U = T>
+ constexpr CheckedContiguousIterator(PtrIfSafeToMemmove<U> ptr)
+ : start_(ptr), current_(ptr), end_(ptr) {}
+
+ template <int&... ExplicitArgumentBarrier, typename U = T>
+ friend constexpr PtrIfSafeToMemmove<U> __unwrap_iter(
+ CheckedContiguousIterator iter) {
+ return iter.current_;
+ }
+#endif
+
+ constexpr CheckedContiguousIterator(T* start, const T* end)
+ : CheckedContiguousIterator(start, start, end) {}
+ constexpr CheckedContiguousIterator(const T* start, T* current, const T* end)
+ : start_(start), current_(current), end_(end) {
+ GURL_CHECK_LE(start, current);
+ GURL_CHECK_LE(current, end);
+ }
+ constexpr CheckedContiguousIterator(const CheckedContiguousIterator& other) =
+ default;
+
+ // Converting constructor allowing conversions like CCI<T> to CCI<const T>,
+ // but disallowing CCI<const T> to CCI<T> or CCI<Derived> to CCI<Base>, which
+ // are unsafe. Furthermore, this is the same condition as used by the
+ // converting constructors of std::span<T> and std::unique_ptr<T[]>.
+ // See https://wg21.link/n4042 for details.
+ template <
+ typename U,
+ std::enable_if_t<std::is_convertible<U (*)[], T (*)[]>::value>* = nullptr>
+ constexpr CheckedContiguousIterator(const CheckedContiguousIterator<U>& other)
+ : start_(other.start_), current_(other.current_), end_(other.end_) {
+ // We explicitly don't delegate to the 3-argument constructor here. Its
+ // CHECKs would be redundant, since we expect |other| to maintain its own
+ // invariant. However, DCHECKs never hurt anybody. Presumably.
+ GURL_DCHECK_LE(other.start_, other.current_);
+ GURL_DCHECK_LE(other.current_, other.end_);
+ }
+
+ ~CheckedContiguousIterator() = default;
+
+ constexpr CheckedContiguousIterator& operator=(
+ const CheckedContiguousIterator& other) = default;
+
+ friend constexpr bool operator==(const CheckedContiguousIterator& lhs,
+ const CheckedContiguousIterator& rhs) {
+ lhs.CheckComparable(rhs);
+ return lhs.current_ == rhs.current_;
+ }
+
+ friend constexpr bool operator!=(const CheckedContiguousIterator& lhs,
+ const CheckedContiguousIterator& rhs) {
+ lhs.CheckComparable(rhs);
+ return lhs.current_ != rhs.current_;
+ }
+
+ friend constexpr bool operator<(const CheckedContiguousIterator& lhs,
+ const CheckedContiguousIterator& rhs) {
+ lhs.CheckComparable(rhs);
+ return lhs.current_ < rhs.current_;
+ }
+
+ friend constexpr bool operator<=(const CheckedContiguousIterator& lhs,
+ const CheckedContiguousIterator& rhs) {
+ lhs.CheckComparable(rhs);
+ return lhs.current_ <= rhs.current_;
+ }
+ friend constexpr bool operator>(const CheckedContiguousIterator& lhs,
+ const CheckedContiguousIterator& rhs) {
+ lhs.CheckComparable(rhs);
+ return lhs.current_ > rhs.current_;
+ }
+
+ friend constexpr bool operator>=(const CheckedContiguousIterator& lhs,
+ const CheckedContiguousIterator& rhs) {
+ lhs.CheckComparable(rhs);
+ return lhs.current_ >= rhs.current_;
+ }
+
+ constexpr CheckedContiguousIterator& operator++() {
+ GURL_CHECK_NE(current_, end_);
+ ++current_;
+ return *this;
+ }
+
+ constexpr CheckedContiguousIterator operator++(int) {
+ CheckedContiguousIterator old = *this;
+ ++*this;
+ return old;
+ }
+
+ constexpr CheckedContiguousIterator& operator--() {
+ GURL_CHECK_NE(current_, start_);
+ --current_;
+ return *this;
+ }
+
+ constexpr CheckedContiguousIterator operator--(int) {
+ CheckedContiguousIterator old = *this;
+ --*this;
+ return old;
+ }
+
+ constexpr CheckedContiguousIterator& operator+=(difference_type rhs) {
+ if (rhs > 0) {
+ GURL_CHECK_LE(rhs, end_ - current_);
+ } else {
+ GURL_CHECK_LE(-rhs, current_ - start_);
+ }
+ current_ += rhs;
+ return *this;
+ }
+
+ constexpr CheckedContiguousIterator operator+(difference_type rhs) const {
+ CheckedContiguousIterator it = *this;
+ it += rhs;
+ return it;
+ }
+
+ constexpr CheckedContiguousIterator& operator-=(difference_type rhs) {
+ if (rhs < 0) {
+ GURL_CHECK_LE(-rhs, end_ - current_);
+ } else {
+ GURL_CHECK_LE(rhs, current_ - start_);
+ }
+ current_ -= rhs;
+ return *this;
+ }
+
+ constexpr CheckedContiguousIterator operator-(difference_type rhs) const {
+ CheckedContiguousIterator it = *this;
+ it -= rhs;
+ return it;
+ }
+
+ constexpr friend difference_type operator-(
+ const CheckedContiguousIterator& lhs,
+ const CheckedContiguousIterator& rhs) {
+ lhs.CheckComparable(rhs);
+ return lhs.current_ - rhs.current_;
+ }
+
+ constexpr reference operator*() const {
+ GURL_CHECK_NE(current_, end_);
+ return *current_;
+ }
+
+ constexpr pointer operator->() const {
+ GURL_CHECK_NE(current_, end_);
+ return current_;
+ }
+
+ constexpr reference operator[](difference_type rhs) const {
+ GURL_CHECK_GE(rhs, 0);
+ GURL_CHECK_LT(rhs, end_ - current_);
+ return current_[rhs];
+ }
+
+ static bool IsRangeMoveSafe(const CheckedContiguousIterator& from_begin,
+ const CheckedContiguousIterator& from_end,
+ const CheckedContiguousIterator& to)
+ WARN_UNUSED_RESULT {
+ if (from_end < from_begin)
+ return false;
+ const auto from_begin_uintptr = get_uintptr(from_begin.current_);
+ const auto from_end_uintptr = get_uintptr(from_end.current_);
+ const auto to_begin_uintptr = get_uintptr(to.current_);
+ const auto to_end_uintptr =
+ get_uintptr((to + std::distance(from_begin, from_end)).current_);
+
+ return to_begin_uintptr >= from_end_uintptr ||
+ to_end_uintptr <= from_begin_uintptr;
+ }
+
+ private:
+ constexpr void CheckComparable(const CheckedContiguousIterator& other) const {
+ GURL_CHECK_EQ(start_, other.start_);
+ GURL_CHECK_EQ(end_, other.end_);
+ }
+
+ const T* start_ = nullptr;
+ T* current_ = nullptr;
+ const T* end_ = nullptr;
+};
+
+template <typename T>
+using CheckedContiguousConstIterator = CheckedContiguousIterator<const T>;
+
+} // namespace base
+
+#endif // BASE_CONTAINERS_CHECKED_ITERATORS_H_
diff --git a/base/containers/span.h b/base/containers/span.h
new file mode 100644
index 0000000..45a322d
--- /dev/null
+++ b/base/containers/span.h
@@ -0,0 +1,474 @@
+// Copyright 2017 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_CONTAINERS_SPAN_H_
+#define BASE_CONTAINERS_SPAN_H_
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <array>
+#include <iterator>
+#include <limits>
+#include <type_traits>
+#include <utility>
+
+#include "polyfills/base/check_op.h"
+#include "base/containers/checked_iterators.h"
+#include "base/macros.h"
+#include "base/stl_util.h"
+#include "base/template_util.h"
+
+namespace gurl_base {
+
+// [views.constants]
+constexpr size_t dynamic_extent = std::numeric_limits<size_t>::max();
+
+template <typename T, size_t Extent = dynamic_extent>
+class span;
+
+namespace internal {
+
+template <size_t I>
+using size_constant = std::integral_constant<size_t, I>;
+
+template <typename T>
+struct ExtentImpl : size_constant<dynamic_extent> {};
+
+template <typename T, size_t N>
+struct ExtentImpl<T[N]> : size_constant<N> {};
+
+template <typename T, size_t N>
+struct ExtentImpl<std::array<T, N>> : size_constant<N> {};
+
+template <typename T, size_t N>
+struct ExtentImpl<gurl_base::span<T, N>> : size_constant<N> {};
+
+template <typename T>
+using Extent = ExtentImpl<std::remove_cv_t<std::remove_reference_t<T>>>;
+
+template <typename T>
+struct IsSpanImpl : std::false_type {};
+
+template <typename T, size_t Extent>
+struct IsSpanImpl<span<T, Extent>> : std::true_type {};
+
+template <typename T>
+using IsNotSpan = negation<IsSpanImpl<std::decay_t<T>>>;
+
+template <typename T>
+struct IsStdArrayImpl : std::false_type {};
+
+template <typename T, size_t N>
+struct IsStdArrayImpl<std::array<T, N>> : std::true_type {};
+
+template <typename T>
+using IsNotStdArray = negation<IsStdArrayImpl<std::decay_t<T>>>;
+
+template <typename T>
+using IsNotCArray = negation<std::is_array<std::remove_reference_t<T>>>;
+
+template <typename From, typename To>
+using IsLegalDataConversion = std::is_convertible<From (*)[], To (*)[]>;
+
+template <typename Container, typename T>
+using ContainerHasConvertibleData = IsLegalDataConversion<
+ std::remove_pointer_t<decltype(gurl_base::data(std::declval<Container>()))>,
+ T>;
+
+template <typename Container>
+using ContainerHasIntegralSize =
+ std::is_integral<decltype(gurl_base::size(std::declval<Container>()))>;
+
+template <typename From, size_t FromExtent, typename To, size_t ToExtent>
+using EnableIfLegalSpanConversion =
+ std::enable_if_t<(ToExtent == dynamic_extent || ToExtent == FromExtent) &&
+ IsLegalDataConversion<From, To>::value>;
+
+// SFINAE check if Array can be converted to a span<T>.
+template <typename Array, typename T, size_t Extent>
+using EnableIfSpanCompatibleArray =
+ std::enable_if_t<(Extent == dynamic_extent ||
+ Extent == internal::Extent<Array>::value) &&
+ ContainerHasConvertibleData<Array, T>::value>;
+
+// SFINAE check if Container can be converted to a span<T>.
+template <typename Container, typename T>
+using IsSpanCompatibleContainer =
+ conjunction<IsNotSpan<Container>,
+ IsNotStdArray<Container>,
+ IsNotCArray<Container>,
+ ContainerHasConvertibleData<Container, T>,
+ ContainerHasIntegralSize<Container>>;
+
+template <typename Container, typename T>
+using EnableIfSpanCompatibleContainer =
+ std::enable_if_t<IsSpanCompatibleContainer<Container, T>::value>;
+
+template <typename Container, typename T, size_t Extent>
+using EnableIfSpanCompatibleContainerAndSpanIsDynamic =
+ std::enable_if_t<IsSpanCompatibleContainer<Container, T>::value &&
+ Extent == dynamic_extent>;
+
+// A helper template for storing the size of a span. Spans with static extents
+// don't require additional storage, since the extent itself is specified in the
+// template parameter.
+template <size_t Extent>
+class ExtentStorage {
+ public:
+ constexpr explicit ExtentStorage(size_t size) noexcept {}
+ constexpr size_t size() const noexcept { return Extent; }
+};
+
+// Specialization of ExtentStorage for dynamic extents, which do require
+// explicit storage for the size.
+template <>
+struct ExtentStorage<dynamic_extent> {
+ constexpr explicit ExtentStorage(size_t size) noexcept : size_(size) {}
+ constexpr size_t size() const noexcept { return size_; }
+
+ private:
+ size_t size_;
+};
+
+} // namespace internal
+
+// A span is a value type that represents an array of elements of type T. Since
+// it only consists of a pointer to memory with an associated size, it is very
+// light-weight. It is cheap to construct, copy, move and use spans, so that
+// users are encouraged to use it as a pass-by-value parameter. A span does not
+// own the underlying memory, so care must be taken to ensure that a span does
+// not outlive the backing store.
+//
+// span is somewhat analogous to StringPiece, but with arbitrary element types,
+// allowing mutation if T is non-const.
+//
+// span is implicitly convertible from C++ arrays, as well as most [1]
+// container-like types that provide a data() and size() method (such as
+// std::vector<T>). A mutable span<T> can also be implicitly converted to an
+// immutable span<const T>.
+//
+// Consider using a span for functions that take a data pointer and size
+// parameter: it allows the function to still act on an array-like type, while
+// allowing the caller code to be a bit more concise.
+//
+// For read-only data access pass a span<const T>: the caller can supply either
+// a span<const T> or a span<T>, while the callee will have a read-only view.
+// For read-write access a mutable span<T> is required.
+//
+// Without span:
+// Read-Only:
+// // std::string HexEncode(const uint8_t* data, size_t size);
+// std::vector<uint8_t> data_buffer = GenerateData();
+// std::string r = HexEncode(data_buffer.data(), data_buffer.size());
+//
+// Mutable:
+// // ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt, Args...);
+// char str_buffer[100];
+// SafeSNPrintf(str_buffer, sizeof(str_buffer), "Pi ~= %lf", 3.14);
+//
+// With span:
+// Read-Only:
+// // std::string HexEncode(gurl_base::span<const uint8_t> data);
+// std::vector<uint8_t> data_buffer = GenerateData();
+// std::string r = HexEncode(data_buffer);
+//
+// Mutable:
+// // ssize_t SafeSNPrintf(gurl_base::span<char>, const char* fmt, Args...);
+// char str_buffer[100];
+// SafeSNPrintf(str_buffer, "Pi ~= %lf", 3.14);
+//
+// Spans with "const" and pointers
+// -------------------------------
+//
+// Const and pointers can get confusing. Here are vectors of pointers and their
+// corresponding spans:
+//
+// const std::vector<int*> => gurl_base::span<int* const>
+// std::vector<const int*> => gurl_base::span<const int*>
+// const std::vector<const int*> => gurl_base::span<const int* const>
+//
+// Differences from the C++20 draft
+// --------------------------------
+//
+// http://eel.is/c++draft/views contains the latest C++20 draft of std::span.
+// Chromium tries to follow the draft as close as possible. Differences between
+// the draft and the implementation are documented in subsections below.
+//
+// Differences from [span.objectrep]:
+// - as_bytes() and as_writable_bytes() return spans of uint8_t instead of
+// std::byte (std::byte is a C++17 feature)
+//
+// Differences from [span.cons]:
+// - Constructing a static span (i.e. Extent != dynamic_extent) from a dynamic
+// sized container (e.g. std::vector) requires an explicit conversion (in the
+// C++20 draft this is simply UB)
+//
+// Differences from [span.obs]:
+// - empty() is marked with WARN_UNUSED_RESULT instead of [[nodiscard]]
+// ([[nodiscard]] is a C++17 feature)
+//
+// Furthermore, all constructors and methods are marked noexcept due to the lack
+// of exceptions in Chromium.
+//
+// Due to the lack of class template argument deduction guides in C++14
+// appropriate make_span() utility functions are provided.
+
+// [span], class template span
+template <typename T, size_t Extent>
+class span : public internal::ExtentStorage<Extent> {
+ private:
+ using ExtentStorage = internal::ExtentStorage<Extent>;
+
+ public:
+ using element_type = T;
+ using value_type = std::remove_cv_t<T>;
+ using size_type = size_t;
+ using difference_type = ptrdiff_t;
+ using pointer = T*;
+ using reference = T&;
+ using iterator = CheckedContiguousIterator<T>;
+ // TODO(https://crbug.com/828324): Drop the const_iterator typedef once gMock
+ // supports containers without this nested type.
+ using const_iterator = iterator;
+ using reverse_iterator = std::reverse_iterator<iterator>;
+ static constexpr size_t extent = Extent;
+
+ // [span.cons], span constructors, copy, assignment, and destructor
+ constexpr span() noexcept : ExtentStorage(0), data_(nullptr) {
+ static_assert(Extent == dynamic_extent || Extent == 0, "Invalid Extent");
+ }
+
+ constexpr span(T* data, size_t size) noexcept
+ : ExtentStorage(size), data_(data) {
+ GURL_CHECK(Extent == dynamic_extent || Extent == size);
+ }
+
+ // Artificially templatized to break ambiguity for span(ptr, 0).
+ template <typename = void>
+ constexpr span(T* begin, T* end) noexcept : span(begin, end - begin) {
+ // Note: GURL_CHECK_LE is not constexpr, hence regular GURL_CHECK must be used.
+ GURL_CHECK(begin <= end);
+ }
+
+ template <
+ size_t N,
+ typename = internal::EnableIfSpanCompatibleArray<T (&)[N], T, Extent>>
+ constexpr span(T (&array)[N]) noexcept : span(gurl_base::data(array), N) {}
+
+ template <
+ typename U,
+ size_t N,
+ typename =
+ internal::EnableIfSpanCompatibleArray<std::array<U, N>&, T, Extent>>
+ constexpr span(std::array<U, N>& array) noexcept
+ : span(gurl_base::data(array), N) {}
+
+ template <typename U,
+ size_t N,
+ typename = internal::
+ EnableIfSpanCompatibleArray<const std::array<U, N>&, T, Extent>>
+ constexpr span(const std::array<U, N>& array) noexcept
+ : span(gurl_base::data(array), N) {}
+
+ // Conversion from a container that has compatible gurl_base::data() and integral
+ // gurl_base::size().
+ template <
+ typename Container,
+ typename =
+ internal::EnableIfSpanCompatibleContainerAndSpanIsDynamic<Container&,
+ T,
+ Extent>>
+ constexpr span(Container& container) noexcept
+ : span(gurl_base::data(container), gurl_base::size(container)) {}
+
+ template <
+ typename Container,
+ typename = internal::EnableIfSpanCompatibleContainerAndSpanIsDynamic<
+ const Container&,
+ T,
+ Extent>>
+ constexpr span(const Container& container) noexcept
+ : span(gurl_base::data(container), gurl_base::size(container)) {}
+
+ constexpr span(const span& other) noexcept = default;
+
+ // Conversions from spans of compatible types and extents: this allows a
+ // span<T> to be seamlessly used as a span<const T>, but not the other way
+ // around. If extent is not dynamic, OtherExtent has to be equal to Extent.
+ template <
+ typename U,
+ size_t OtherExtent,
+ typename =
+ internal::EnableIfLegalSpanConversion<U, OtherExtent, T, Extent>>
+ constexpr span(const span<U, OtherExtent>& other)
+ : span(other.data(), other.size()) {}
+
+ constexpr span& operator=(const span& other) noexcept = default;
+ ~span() noexcept = default;
+
+ // [span.sub], span subviews
+ template <size_t Count>
+ constexpr span<T, Count> first() const noexcept {
+ static_assert(Count <= Extent, "Count must not exceed Extent");
+ GURL_CHECK(Extent != dynamic_extent || Count <= size());
+ return {data(), Count};
+ }
+
+ template <size_t Count>
+ constexpr span<T, Count> last() const noexcept {
+ static_assert(Count <= Extent, "Count must not exceed Extent");
+ GURL_CHECK(Extent != dynamic_extent || Count <= size());
+ return {data() + (size() - Count), Count};
+ }
+
+ template <size_t Offset, size_t Count = dynamic_extent>
+ constexpr span<T,
+ (Count != dynamic_extent
+ ? Count
+ : (Extent != dynamic_extent ? Extent - Offset
+ : dynamic_extent))>
+ subspan() const noexcept {
+ static_assert(Offset <= Extent, "Offset must not exceed Extent");
+ static_assert(Count == dynamic_extent || Count <= Extent - Offset,
+ "Count must not exceed Extent - Offset");
+ GURL_CHECK(Extent != dynamic_extent || Offset <= size());
+ GURL_CHECK(Extent != dynamic_extent || Count == dynamic_extent ||
+ Count <= size() - Offset);
+ return {data() + Offset, Count != dynamic_extent ? Count : size() - Offset};
+ }
+
+ constexpr span<T, dynamic_extent> first(size_t count) const noexcept {
+ // Note: GURL_CHECK_LE is not constexpr, hence regular GURL_CHECK must be used.
+ GURL_CHECK(count <= size());
+ return {data(), count};
+ }
+
+ constexpr span<T, dynamic_extent> last(size_t count) const noexcept {
+ // Note: GURL_CHECK_LE is not constexpr, hence regular GURL_CHECK must be used.
+ GURL_CHECK(count <= size());
+ return {data() + (size() - count), count};
+ }
+
+ constexpr span<T, dynamic_extent> subspan(size_t offset,
+ size_t count = dynamic_extent) const
+ noexcept {
+ // Note: GURL_CHECK_LE is not constexpr, hence regular GURL_CHECK must be used.
+ GURL_CHECK(offset <= size());
+ GURL_CHECK(count == dynamic_extent || count <= size() - offset);
+ return {data() + offset, count != dynamic_extent ? count : size() - offset};
+ }
+
+ // [span.obs], span observers
+ constexpr size_t size() const noexcept { return ExtentStorage::size(); }
+ constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
+ constexpr bool empty() const noexcept WARN_UNUSED_RESULT {
+ return size() == 0;
+ }
+
+ // [span.elem], span element access
+ constexpr T& operator[](size_t idx) const noexcept {
+ // Note: GURL_CHECK_LT is not constexpr, hence regular GURL_CHECK must be used.
+ GURL_CHECK(idx < size());
+ return *(data() + idx);
+ }
+
+ constexpr T& front() const noexcept {
+ static_assert(Extent == dynamic_extent || Extent > 0,
+ "Extent must not be 0");
+ GURL_CHECK(Extent != dynamic_extent || !empty());
+ return *data();
+ }
+
+ constexpr T& back() const noexcept {
+ static_assert(Extent == dynamic_extent || Extent > 0,
+ "Extent must not be 0");
+ GURL_CHECK(Extent != dynamic_extent || !empty());
+ return *(data() + size() - 1);
+ }
+
+ constexpr T* data() const noexcept { return data_; }
+
+ // [span.iter], span iterator support
+ constexpr iterator begin() const noexcept {
+ return iterator(data_, data_ + size());
+ }
+
+ constexpr iterator end() const noexcept {
+ return iterator(data_, data_ + size(), data_ + size());
+ }
+
+ constexpr reverse_iterator rbegin() const noexcept {
+ return reverse_iterator(end());
+ }
+
+ constexpr reverse_iterator rend() const noexcept {
+ return reverse_iterator(begin());
+ }
+
+ private:
+ T* data_;
+};
+
+// span<T, Extent>::extent can not be declared inline prior to C++17, hence this
+// definition is required.
+template <class T, size_t Extent>
+constexpr size_t span<T, Extent>::extent;
+
+// [span.objectrep], views of object representation
+template <typename T, size_t X>
+span<const uint8_t, (X == dynamic_extent ? dynamic_extent : sizeof(T) * X)>
+as_bytes(span<T, X> s) noexcept {
+ return {reinterpret_cast<const uint8_t*>(s.data()), s.size_bytes()};
+}
+
+template <typename T,
+ size_t X,
+ typename = std::enable_if_t<!std::is_const<T>::value>>
+span<uint8_t, (X == dynamic_extent ? dynamic_extent : sizeof(T) * X)>
+as_writable_bytes(span<T, X> s) noexcept {
+ return {reinterpret_cast<uint8_t*>(s.data()), s.size_bytes()};
+}
+
+// Type-deducing helpers for constructing a span.
+template <int&... ExplicitArgumentBarrier, typename T>
+constexpr span<T> make_span(T* data, size_t size) noexcept {
+ return {data, size};
+}
+
+template <int&... ExplicitArgumentBarrier, typename T>
+constexpr span<T> make_span(T* begin, T* end) noexcept {
+ return {begin, end};
+}
+
+// make_span utility function that deduces both the span's value_type and extent
+// from the passed in argument.
+//
+// Usage: auto span = gurl_base::make_span(...);
+template <int&... ExplicitArgumentBarrier, typename Container>
+constexpr auto make_span(Container&& container) noexcept {
+ using T =
+ std::remove_pointer_t<decltype(gurl_base::data(std::declval<Container>()))>;
+ using Extent = internal::Extent<Container>;
+ return span<T, Extent::value>(std::forward<Container>(container));
+}
+
+// make_span utility function that allows 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.
+//
+// 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 Container>
+constexpr auto make_span(Container&& container) noexcept {
+ using T =
+ std::remove_pointer_t<decltype(gurl_base::data(std::declval<Container>()))>;
+ return span<T, N>(gurl_base::data(container), gurl_base::size(container));
+}
+
+} // namespace base
+
+#endif // BASE_CONTAINERS_SPAN_H_
diff --git a/base/containers/util.h b/base/containers/util.h
new file mode 100644
index 0000000..14f012a
--- /dev/null
+++ b/base/containers/util.h
@@ -0,0 +1,21 @@
+// Copyright 2018 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_CONTAINERS_UTIL_H_
+#define BASE_CONTAINERS_UTIL_H_
+
+#include <stdint.h>
+
+namespace gurl_base {
+
+// TODO(crbug.com/817982): What we really need is for checked_math.h to be
+// able to do checked arithmetic on pointers.
+template <typename T>
+static inline uintptr_t get_uintptr(const T* t) {
+ return reinterpret_cast<uintptr_t>(t);
+}
+
+} // namespace base
+
+#endif // BASE_CONTAINERS_UTIL_H_
diff --git a/base/optional.h b/base/optional.h
index a043122..f07cc66 100644
--- a/base/optional.h
+++ b/base/optional.h
@@ -9,7 +9,7 @@
#include <type_traits>
#include <utility>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check.h"
#include "base/template_util.h"
namespace gurl_base {
@@ -359,27 +359,23 @@
// Helper to conditionally enable converting constructors and assign operators.
template <typename T, typename U>
-struct IsConvertibleFromOptional
- : std::integral_constant<
- bool,
- std::is_constructible<T, Optional<U>&>::value ||
- std::is_constructible<T, const Optional<U>&>::value ||
- std::is_constructible<T, Optional<U>&&>::value ||
- std::is_constructible<T, const Optional<U>&&>::value ||
- std::is_convertible<Optional<U>&, T>::value ||
- std::is_convertible<const Optional<U>&, T>::value ||
- std::is_convertible<Optional<U>&&, T>::value ||
- std::is_convertible<const Optional<U>&&, T>::value> {};
+using IsConvertibleFromOptional =
+ disjunction<std::is_constructible<T, Optional<U>&>,
+ std::is_constructible<T, const Optional<U>&>,
+ std::is_constructible<T, Optional<U>&&>,
+ std::is_constructible<T, const Optional<U>&&>,
+ std::is_convertible<Optional<U>&, T>,
+ std::is_convertible<const Optional<U>&, T>,
+ std::is_convertible<Optional<U>&&, T>,
+ std::is_convertible<const Optional<U>&&, T>>;
template <typename T, typename U>
-struct IsAssignableFromOptional
- : std::integral_constant<
- bool,
- IsConvertibleFromOptional<T, U>::value ||
- std::is_assignable<T&, Optional<U>&>::value ||
- std::is_assignable<T&, const Optional<U>&>::value ||
- std::is_assignable<T&, Optional<U>&&>::value ||
- std::is_assignable<T&, const Optional<U>&&>::value> {};
+using IsAssignableFromOptional =
+ disjunction<IsConvertibleFromOptional<T, U>,
+ std::is_assignable<T&, Optional<U>&>,
+ std::is_assignable<T&, const Optional<U>&>,
+ std::is_assignable<T&, Optional<U>&&>,
+ std::is_assignable<T&, const Optional<U>&&>>;
// Forward compatibility for C++17.
// Introduce one more deeper nested namespace to avoid leaking using std::swap.
diff --git a/base/stl_util.h b/base/stl_util.h
index 7fc8108..14d2b6f 100644
--- a/base/stl_util.h
+++ b/base/stl_util.h
@@ -23,7 +23,7 @@
#include <utility>
#include <vector>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check.h"
#include "base/optional.h"
#include "base/template_util.h"
@@ -561,14 +561,6 @@
return removed;
}
-template <class T, class Allocator, class Value>
-size_t Erase(std::forward_list<T, Allocator>& container, const Value& value) {
- // Unlike std::forward_list::remove, this function template accepts
- // heterogeneous types and does not force a conversion to the container's
- // value type before invoking the == operator.
- return EraseIf(container, [&](const T& cur) { return cur == value; });
-}
-
template <class T, class Allocator, class Predicate>
size_t EraseIf(std::forward_list<T, Allocator>& container, Predicate pred) {
// Note: std::forward_list does not have a size() API, thus we need to use the
@@ -579,14 +571,6 @@
return old_size - std::distance(container.begin(), container.end());
}
-template <class T, class Allocator, class Value>
-size_t Erase(std::list<T, Allocator>& container, const Value& value) {
- // Unlike std::list::remove, this function template accepts heterogeneous
- // types and does not force a conversion to the container's value type before
- // invoking the == operator.
- return EraseIf(container, [&](const T& cur) { return cur == value; });
-}
-
template <class T, class Allocator, class Predicate>
size_t EraseIf(std::list<T, Allocator>& container, Predicate pred) {
size_t old_size = container.size();
@@ -661,6 +645,22 @@
return internal::IterateAndEraseIf(container, pred);
}
+template <class T, class Allocator, class Value>
+size_t Erase(std::forward_list<T, Allocator>& container, const Value& value) {
+ // Unlike std::forward_list::remove, this function template accepts
+ // heterogeneous types and does not force a conversion to the container's
+ // value type before invoking the == operator.
+ return EraseIf(container, [&](const T& cur) { return cur == value; });
+}
+
+template <class T, class Allocator, class Value>
+size_t Erase(std::list<T, Allocator>& container, const Value& value) {
+ // Unlike std::list::remove, this function template accepts heterogeneous
+ // types and does not force a conversion to the container's value type before
+ // invoking the == operator.
+ return EraseIf(container, [&](const T& cur) { return cur == value; });
+}
+
// A helper class to be used as the predicate with |EraseIf| to implement
// in-place set intersection. Helps implement the algorithm of going through
// each container an element at a time, erasing elements from the first
diff --git a/base/strings/BUILD b/base/strings/BUILD
index 5043906..604cc81 100644
--- a/base/strings/BUILD
+++ b/base/strings/BUILD
@@ -19,6 +19,7 @@
"string_piece.h",
"string_piece_forward.h",
"string_util.h",
+ "string_util_internal.h",
"string_util_posix.h",
"utf_string_conversion_utils.h",
"utf_string_conversions.h",
diff --git a/base/strings/no_trigraphs_unittest.cc b/base/strings/no_trigraphs_unittest.cc
new file mode 100644
index 0000000..91fbda5
--- /dev/null
+++ b/base/strings/no_trigraphs_unittest.cc
@@ -0,0 +1,10 @@
+// Copyright 2020 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.
+
+#include "base/strings/strcat.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+TEST(NoTrigraphs, Basic) {
+ EXPECT_EQ("??=", gurl_base::StrCat({"?", "?", "="}));
+}
diff --git a/base/strings/safe_sprintf.cc b/base/strings/safe_sprintf.cc
index ab6e112..726ccf9 100644
--- a/base/strings/safe_sprintf.cc
+++ b/base/strings/safe_sprintf.cc
@@ -35,7 +35,7 @@
// errno = 13 (Access denied)
// In most of the anticipated use cases, that's probably the preferred
// behavior.
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check.h"
#define DEBUG_CHECK RAW_CHECK
#else
#define DEBUG_CHECK(x) do { if (x) { } } while (0)
diff --git a/base/strings/safe_sprintf_unittest.cc b/base/strings/safe_sprintf_unittest.cc
index b7a67fa..cde415d 100644
--- a/base/strings/safe_sprintf_unittest.cc
+++ b/base/strings/safe_sprintf_unittest.cc
@@ -12,7 +12,7 @@
#include <limits>
#include <memory>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check_op.h"
#include "base/macros.h"
#include "build/build_config.h"
#include "testing/gtest/include/gtest/gtest.h"
diff --git a/base/strings/strcat.cc b/base/strings/strcat.cc
index db41a69..6b007c7 100644
--- a/base/strings/strcat.cc
+++ b/base/strings/strcat.cc
@@ -4,82 +4,42 @@
#include "base/strings/strcat.h"
+#include <string>
+
+#include "base/strings/strcat_internal.h"
+
namespace gurl_base {
-namespace {
-
-// Reserves an additional amount of capacity in the given string, growing by at
-// least 2x if necessary. Used by StrAppendT().
-//
-// The "at least 2x" growing rule duplicates the exponential growth of
-// std::string. The problem is that most implementations of reserve() will grow
-// exactly to the requested amount instead of exponentially growing like would
-// happen when appending normally. If we didn't do this, an append after the
-// call to StrAppend() would definitely cause a reallocation, and loops with
-// StrAppend() calls would have O(n^2) complexity to execute. Instead, we want
-// StrAppend() to have the same semantics as std::string::append().
-template <typename String>
-void ReserveAdditionalIfNeeded(String* str,
- typename String::size_type additional) {
- const size_t required = str->size() + additional;
- // Check whether we need to reserve additional capacity at all.
- if (required <= str->capacity())
- return;
-
- str->reserve(std::max(required, str->capacity() * 2));
-}
-
-template <typename DestString, typename InputString>
-void StrAppendT(DestString* dest, span<const InputString> pieces) {
- size_t additional_size = 0;
- for (const auto& cur : pieces)
- additional_size += cur.size();
- ReserveAdditionalIfNeeded(dest, additional_size);
-
- for (const auto& cur : pieces)
- dest->append(cur.data(), cur.size());
-}
-
-} // namespace
-
std::string StrCat(span<const StringPiece> pieces) {
- std::string result;
- StrAppendT(&result, pieces);
- return result;
+ return internal::StrCatT(pieces);
}
string16 StrCat(span<const StringPiece16> pieces) {
- string16 result;
- StrAppendT(&result, pieces);
- return result;
+ return internal::StrCatT(pieces);
}
std::string StrCat(span<const std::string> pieces) {
- std::string result;
- StrAppendT(&result, pieces);
- return result;
+ return internal::StrCatT(pieces);
}
string16 StrCat(span<const string16> pieces) {
- string16 result;
- StrAppendT(&result, pieces);
- return result;
+ return internal::StrCatT(pieces);
}
void StrAppend(std::string* dest, span<const StringPiece> pieces) {
- StrAppendT(dest, pieces);
+ internal::StrAppendT(dest, pieces);
}
void StrAppend(string16* dest, span<const StringPiece16> pieces) {
- StrAppendT(dest, pieces);
+ internal::StrAppendT(dest, pieces);
}
void StrAppend(std::string* dest, span<const std::string> pieces) {
- StrAppendT(dest, pieces);
+ internal::StrAppendT(dest, pieces);
}
void StrAppend(string16* dest, span<const string16> pieces) {
- StrAppendT(dest, pieces);
+ internal::StrAppendT(dest, pieces);
}
} // namespace base
diff --git a/base/strings/strcat.h b/base/strings/strcat.h
index 220fa24..2d85304 100644
--- a/base/strings/strcat.h
+++ b/base/strings/strcat.h
@@ -69,10 +69,11 @@
// Initializer list forwards to the array version.
inline std::string StrCat(std::initializer_list<StringPiece> pieces) {
- return StrCat(make_span(pieces.begin(), pieces.size()));
+ return StrCat(make_span(pieces));
}
+
inline string16 StrCat(std::initializer_list<StringPiece16> pieces) {
- return StrCat(make_span(pieces.begin(), pieces.size()));
+ return StrCat(make_span(pieces));
}
// StrAppend -------------------------------------------------------------------
@@ -91,13 +92,18 @@
// Initializer list forwards to the array version.
inline void StrAppend(std::string* dest,
std::initializer_list<StringPiece> pieces) {
- return StrAppend(dest, make_span(pieces.begin(), pieces.size()));
+ StrAppend(dest, make_span(pieces));
}
+
inline void StrAppend(string16* dest,
std::initializer_list<StringPiece16> pieces) {
- return StrAppend(dest, make_span(pieces.begin(), pieces.size()));
+ StrAppend(dest, make_span(pieces));
}
} // namespace base
+#if defined(OS_WIN)
+#include "base/strings/strcat_win.h"
+#endif
+
#endif // BASE_STRINGS_STRCAT_H_
diff --git a/base/strings/strcat_internal.h b/base/strings/strcat_internal.h
new file mode 100644
index 0000000..24387d6
--- /dev/null
+++ b/base/strings/strcat_internal.h
@@ -0,0 +1,60 @@
+// Copyright 2020 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_STRINGS_STRCAT_INTERNAL_H_
+#define BASE_STRINGS_STRCAT_INTERNAL_H_
+
+#include <string>
+
+#include "base/containers/span.h"
+
+namespace gurl_base {
+
+namespace internal {
+
+// Reserves an additional amount of capacity in the given string, growing by at
+// least 2x if necessary. Used by StrAppendT().
+//
+// The "at least 2x" growing rule duplicates the exponential growth of
+// std::string. The problem is that most implementations of reserve() will grow
+// exactly to the requested amount instead of exponentially growing like would
+// happen when appending normally. If we didn't do this, an append after the
+// call to StrAppend() would definitely cause a reallocation, and loops with
+// StrAppend() calls would have O(n^2) complexity to execute. Instead, we want
+// StrAppend() to have the same semantics as std::string::append().
+template <typename String>
+void ReserveAdditionalIfNeeded(String* str,
+ typename String::size_type additional) {
+ const size_t required = str->size() + additional;
+ // Check whether we need to reserve additional capacity at all.
+ if (required <= str->capacity())
+ return;
+
+ str->reserve(std::max(required, str->capacity() * 2));
+}
+
+template <typename DestString, typename InputString>
+void StrAppendT(DestString* dest, span<const InputString> pieces) {
+ size_t additional_size = 0;
+ for (const auto& cur : pieces)
+ additional_size += cur.size();
+ ReserveAdditionalIfNeeded(dest, additional_size);
+
+ for (const auto& cur : pieces)
+ dest->append(cur.data(), cur.size());
+}
+
+template <typename StringT>
+auto StrCatT(span<const StringT> pieces) {
+ std::basic_string<typename StringT::value_type, typename StringT::traits_type>
+ result;
+ StrAppendT(&result, pieces);
+ return result;
+}
+
+} // namespace internal
+
+} // namespace base
+
+#endif // BASE_STRINGS_STRCAT_INTERNAL_H_
diff --git a/base/strings/strcat_win.cc b/base/strings/strcat_win.cc
new file mode 100644
index 0000000..60b22bc
--- /dev/null
+++ b/base/strings/strcat_win.cc
@@ -0,0 +1,35 @@
+// Copyright 2020 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.
+
+#include "base/strings/strcat_win.h"
+
+#include <string>
+
+#include "base/containers/span.h"
+#include "base/strings/strcat_internal.h"
+#include "base/strings/string_piece.h"
+
+namespace gurl_base {
+
+#if defined(BASE_STRING16_IS_STD_U16STRING)
+
+std::wstring StrCat(span<const WStringPiece> pieces) {
+ return internal::StrCatT(pieces);
+}
+
+std::wstring StrCat(span<const std::wstring> pieces) {
+ return internal::StrCatT(pieces);
+}
+
+void StrAppend(std::wstring* dest, span<const WStringPiece> pieces) {
+ internal::StrAppendT(dest, pieces);
+}
+
+void StrAppend(std::wstring* dest, span<const std::wstring> pieces) {
+ internal::StrAppendT(dest, pieces);
+}
+
+#endif
+
+} // namespace base
diff --git a/base/strings/strcat_win.h b/base/strings/strcat_win.h
new file mode 100644
index 0000000..68f8a58
--- /dev/null
+++ b/base/strings/strcat_win.h
@@ -0,0 +1,45 @@
+// Copyright 2020 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_STRINGS_STRCAT_WIN_H_
+#define BASE_STRINGS_STRCAT_WIN_H_
+
+#include <initializer_list>
+#include <string>
+
+#include "polyfills/base/base_export.h"
+#include "base/compiler_specific.h"
+#include "base/containers/span.h"
+#include "base/strings/string_piece.h"
+
+namespace gurl_base {
+
+// The following section contains overloads of the cross-platform APIs for
+// std::wstring and gurl_base::WStringPiece. These are only enabled if std::wstring
+// and gurl_base::string16 are distinct types, as otherwise this would result in an
+// ODR violation.
+// TODO(crbug.com/911896): Remove those guards once gurl_base::string16 is
+// std::u16string.
+#if defined(BASE_STRING16_IS_STD_U16STRING)
+BASE_EXPORT void StrAppend(std::wstring* dest, span<const WStringPiece> pieces);
+BASE_EXPORT void StrAppend(std::wstring* dest, span<const std::wstring> pieces);
+
+inline void StrAppend(std::wstring* dest,
+ std::initializer_list<WStringPiece> pieces) {
+ StrAppend(dest, make_span(pieces));
+}
+
+BASE_EXPORT std::wstring StrCat(span<const WStringPiece> pieces)
+ WARN_UNUSED_RESULT;
+BASE_EXPORT std::wstring StrCat(span<const std::wstring> pieces)
+ WARN_UNUSED_RESULT;
+
+inline std::wstring StrCat(std::initializer_list<WStringPiece> pieces) {
+ return StrCat(make_span(pieces));
+}
+#endif // defined(BASE_STRING16_IS_STD_U16STRING)
+
+} // namespace base
+
+#endif // BASE_STRINGS_STRCAT_WIN_H_
diff --git a/base/strings/string16.cc b/base/strings/string16.cc
index 6ac8b8b..426d5b6 100644
--- a/base/strings/string16.cc
+++ b/base/strings/string16.cc
@@ -13,6 +13,8 @@
#elif defined(WCHAR_T_IS_UTF32)
+#include <string.h>
+
#include <ostream>
#include "base/strings/string_piece.h"
diff --git a/base/strings/string_number_conversions.cc b/base/strings/string_number_conversions.cc
index 701d71c..d1886b1 100644
--- a/base/strings/string_number_conversions.cc
+++ b/base/strings/string_number_conversions.cc
@@ -4,458 +4,120 @@
#include "base/strings/string_number_conversions.h"
-#include <ctype.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <wctype.h>
+#include <iterator>
+#include <string>
-#include <limits>
-#include <type_traits>
-
+#include "base/containers/span.h"
#include "polyfills/base/logging.h"
-#include "base/no_destructor.h"
-#include "base/numerics/safe_math.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/third_party/double_conversion/double-conversion/double-conversion.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_number_conversions_internal.h"
+#include "base/strings/string_piece.h"
namespace gurl_base {
-namespace {
-
-template <typename STR, typename INT>
-struct IntToStringT {
- static STR IntToString(INT value) {
- // log10(2) ~= 0.3 bytes needed per bit or per byte log10(2**8) ~= 2.4.
- // So round up to allocate 3 output characters per byte, plus 1 for '-'.
- const size_t kOutputBufSize =
- 3 * sizeof(INT) + std::numeric_limits<INT>::is_signed;
-
- // Create the string in a temporary buffer, write it back to front, and
- // then return the substr of what we ended up using.
- using CHR = typename STR::value_type;
- CHR outbuf[kOutputBufSize];
-
- // The ValueOrDie call below can never fail, because UnsignedAbs is valid
- // for all valid inputs.
- typename std::make_unsigned<INT>::type res =
- CheckedNumeric<INT>(value).UnsignedAbs().ValueOrDie();
-
- CHR* end = outbuf + kOutputBufSize;
- CHR* i = end;
- do {
- --i;
- GURL_DCHECK(i != outbuf);
- *i = static_cast<CHR>((res % 10) + '0');
- res /= 10;
- } while (res != 0);
- if (IsValueNegative(value)) {
- --i;
- GURL_DCHECK(i != outbuf);
- *i = static_cast<CHR>('-');
- }
- return STR(i, end);
- }
-};
-
-// Utility to convert a character to a digit in a given base
-template<typename CHAR, int BASE, bool BASE_LTE_10> class BaseCharToDigit {
-};
-
-// Faster specialization for bases <= 10
-template<typename CHAR, int BASE> class BaseCharToDigit<CHAR, BASE, true> {
- public:
- static bool Convert(CHAR c, uint8_t* digit) {
- if (c >= '0' && c < '0' + BASE) {
- *digit = static_cast<uint8_t>(c - '0');
- return true;
- }
- return false;
- }
-};
-
-// Specialization for bases where 10 < base <= 36
-template<typename CHAR, int BASE> class BaseCharToDigit<CHAR, BASE, false> {
- public:
- static bool Convert(CHAR c, uint8_t* digit) {
- if (c >= '0' && c <= '9') {
- *digit = c - '0';
- } else if (c >= 'a' && c < 'a' + BASE - 10) {
- *digit = c - 'a' + 10;
- } else if (c >= 'A' && c < 'A' + BASE - 10) {
- *digit = c - 'A' + 10;
- } else {
- return false;
- }
- return true;
- }
-};
-
-template <int BASE, typename CHAR>
-bool CharToDigit(CHAR c, uint8_t* digit) {
- return BaseCharToDigit<CHAR, BASE, BASE <= 10>::Convert(c, digit);
-}
-
-// There is an IsUnicodeWhitespace for wchars defined in string_util.h, but it
-// is locale independent, whereas the functions we are replacing were
-// locale-dependent. TBD what is desired, but for the moment let's not
-// introduce a change in behaviour.
-template<typename CHAR> class WhitespaceHelper {
-};
-
-template<> class WhitespaceHelper<char> {
- public:
- static bool Invoke(char c) {
- return 0 != isspace(static_cast<unsigned char>(c));
- }
-};
-
-template<> class WhitespaceHelper<char16> {
- public:
- static bool Invoke(char16 c) {
- return 0 != iswspace(c);
- }
-};
-
-template<typename CHAR> bool LocalIsWhitespace(CHAR c) {
- return WhitespaceHelper<CHAR>::Invoke(c);
-}
-
-// IteratorRangeToNumberTraits should provide:
-// - a typedef for iterator_type, the iterator type used as input.
-// - a typedef for value_type, the target numeric type.
-// - static functions min, max (returning the minimum and maximum permitted
-// values)
-// - constant kBase, the base in which to interpret the input
-template<typename IteratorRangeToNumberTraits>
-class IteratorRangeToNumber {
- public:
- typedef IteratorRangeToNumberTraits traits;
- typedef typename traits::iterator_type const_iterator;
- typedef typename traits::value_type value_type;
-
- // Generalized iterator-range-to-number conversion.
- //
- static bool Invoke(const_iterator begin,
- const_iterator end,
- value_type* output) {
- bool valid = true;
-
- while (begin != end && LocalIsWhitespace(*begin)) {
- valid = false;
- ++begin;
- }
-
- if (begin != end && *begin == '-') {
- if (!std::numeric_limits<value_type>::is_signed) {
- *output = 0;
- valid = false;
- } else if (!Negative::Invoke(begin + 1, end, output)) {
- valid = false;
- }
- } else {
- if (begin != end && *begin == '+') {
- ++begin;
- }
- if (!Positive::Invoke(begin, end, output)) {
- valid = false;
- }
- }
-
- return valid;
- }
-
- private:
- // Sign provides:
- // - a static function, CheckBounds, that determines whether the next digit
- // causes an overflow/underflow
- // - a static function, Increment, that appends the next digit appropriately
- // according to the sign of the number being parsed.
- template<typename Sign>
- class Base {
- public:
- static bool Invoke(const_iterator begin, const_iterator end,
- typename traits::value_type* output) {
- *output = 0;
-
- if (begin == end) {
- return false;
- }
-
- // Note: no performance difference was found when using template
- // specialization to remove this check in bases other than 16
- if (traits::kBase == 16 && end - begin > 2 && *begin == '0' &&
- (*(begin + 1) == 'x' || *(begin + 1) == 'X')) {
- begin += 2;
- }
-
- for (const_iterator current = begin; current != end; ++current) {
- uint8_t new_digit = 0;
-
- if (!CharToDigit<traits::kBase>(*current, &new_digit)) {
- return false;
- }
-
- if (current != begin) {
- if (!Sign::CheckBounds(output, new_digit)) {
- return false;
- }
- *output *= traits::kBase;
- }
-
- Sign::Increment(new_digit, output);
- }
- return true;
- }
- };
-
- class Positive : public Base<Positive> {
- public:
- static bool CheckBounds(value_type* output, uint8_t new_digit) {
- if (*output > static_cast<value_type>(traits::max() / traits::kBase) ||
- (*output == static_cast<value_type>(traits::max() / traits::kBase) &&
- new_digit > traits::max() % traits::kBase)) {
- *output = traits::max();
- return false;
- }
- return true;
- }
- static void Increment(uint8_t increment, value_type* output) {
- *output += increment;
- }
- };
-
- class Negative : public Base<Negative> {
- public:
- static bool CheckBounds(value_type* output, uint8_t new_digit) {
- if (*output < traits::min() / traits::kBase ||
- (*output == traits::min() / traits::kBase &&
- new_digit > 0 - traits::min() % traits::kBase)) {
- *output = traits::min();
- return false;
- }
- return true;
- }
- static void Increment(uint8_t increment, value_type* output) {
- *output -= increment;
- }
- };
-};
-
-template<typename ITERATOR, typename VALUE, int BASE>
-class BaseIteratorRangeToNumberTraits {
- public:
- typedef ITERATOR iterator_type;
- typedef VALUE value_type;
- static value_type min() {
- return std::numeric_limits<value_type>::min();
- }
- static value_type max() {
- return std::numeric_limits<value_type>::max();
- }
- static const int kBase = BASE;
-};
-
-template<typename ITERATOR>
-class BaseHexIteratorRangeToIntTraits
- : public BaseIteratorRangeToNumberTraits<ITERATOR, int, 16> {
-};
-
-template <typename ITERATOR>
-class BaseHexIteratorRangeToUIntTraits
- : public BaseIteratorRangeToNumberTraits<ITERATOR, uint32_t, 16> {};
-
-template <typename ITERATOR>
-class BaseHexIteratorRangeToInt64Traits
- : public BaseIteratorRangeToNumberTraits<ITERATOR, int64_t, 16> {};
-
-template <typename ITERATOR>
-class BaseHexIteratorRangeToUInt64Traits
- : public BaseIteratorRangeToNumberTraits<ITERATOR, uint64_t, 16> {};
-
-typedef BaseHexIteratorRangeToIntTraits<StringPiece::const_iterator>
- HexIteratorRangeToIntTraits;
-
-typedef BaseHexIteratorRangeToUIntTraits<StringPiece::const_iterator>
- HexIteratorRangeToUIntTraits;
-
-typedef BaseHexIteratorRangeToInt64Traits<StringPiece::const_iterator>
- HexIteratorRangeToInt64Traits;
-
-typedef BaseHexIteratorRangeToUInt64Traits<StringPiece::const_iterator>
- HexIteratorRangeToUInt64Traits;
-
-template <typename VALUE, int BASE>
-class StringPieceToNumberTraits
- : public BaseIteratorRangeToNumberTraits<StringPiece::const_iterator,
- VALUE,
- BASE> {
-};
-
-template <typename VALUE>
-bool StringToIntImpl(StringPiece input, VALUE* output) {
- return IteratorRangeToNumber<StringPieceToNumberTraits<VALUE, 10> >::Invoke(
- input.begin(), input.end(), output);
-}
-
-template <typename VALUE, int BASE>
-class StringPiece16ToNumberTraits
- : public BaseIteratorRangeToNumberTraits<StringPiece16::const_iterator,
- VALUE,
- BASE> {
-};
-
-template <typename VALUE>
-bool String16ToIntImpl(StringPiece16 input, VALUE* output) {
- return IteratorRangeToNumber<StringPiece16ToNumberTraits<VALUE, 10> >::Invoke(
- input.begin(), input.end(), output);
-}
-
-} // namespace
-
std::string NumberToString(int value) {
- return IntToStringT<std::string, int>::IntToString(value);
+ return internal::IntToStringT<std::string>(value);
}
string16 NumberToString16(int value) {
- return IntToStringT<string16, int>::IntToString(value);
+ return internal::IntToStringT<string16>(value);
}
std::string NumberToString(unsigned value) {
- return IntToStringT<std::string, unsigned>::IntToString(value);
+ return internal::IntToStringT<std::string>(value);
}
string16 NumberToString16(unsigned value) {
- return IntToStringT<string16, unsigned>::IntToString(value);
+ return internal::IntToStringT<string16>(value);
}
std::string NumberToString(long value) {
- return IntToStringT<std::string, long>::IntToString(value);
+ return internal::IntToStringT<std::string>(value);
}
string16 NumberToString16(long value) {
- return IntToStringT<string16, long>::IntToString(value);
+ return internal::IntToStringT<string16>(value);
}
std::string NumberToString(unsigned long value) {
- return IntToStringT<std::string, unsigned long>::IntToString(value);
+ return internal::IntToStringT<std::string>(value);
}
string16 NumberToString16(unsigned long value) {
- return IntToStringT<string16, unsigned long>::IntToString(value);
+ return internal::IntToStringT<string16>(value);
}
std::string NumberToString(long long value) {
- return IntToStringT<std::string, long long>::IntToString(value);
+ return internal::IntToStringT<std::string>(value);
}
string16 NumberToString16(long long value) {
- return IntToStringT<string16, long long>::IntToString(value);
+ return internal::IntToStringT<string16>(value);
}
std::string NumberToString(unsigned long long value) {
- return IntToStringT<std::string, unsigned long long>::IntToString(value);
+ return internal::IntToStringT<std::string>(value);
}
string16 NumberToString16(unsigned long long value) {
- return IntToStringT<string16, unsigned long long>::IntToString(value);
-}
-
-static const double_conversion::DoubleToStringConverter*
-GetDoubleToStringConverter() {
- static NoDestructor<double_conversion::DoubleToStringConverter> converter(
- double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN,
- nullptr, nullptr, 'e', -6, 12, 0, 0);
- return converter.get();
+ return internal::IntToStringT<string16>(value);
}
std::string NumberToString(double value) {
- char buffer[32];
- double_conversion::StringBuilder builder(buffer, sizeof(buffer));
- GetDoubleToStringConverter()->ToShortest(value, &builder);
- return std::string(buffer, builder.position());
+ return internal::DoubleToStringT<std::string>(value);
}
-gurl_base::string16 NumberToString16(double value) {
- char buffer[32];
- double_conversion::StringBuilder builder(buffer, sizeof(buffer));
- GetDoubleToStringConverter()->ToShortest(value, &builder);
-
- // The number will be ASCII. This creates the string using the "input
- // iterator" variant which promotes from 8-bit to 16-bit via "=".
- return gurl_base::string16(&buffer[0], &buffer[builder.position()]);
+string16 NumberToString16(double value) {
+ return internal::DoubleToStringT<string16>(value);
}
bool StringToInt(StringPiece input, int* output) {
- return StringToIntImpl(input, output);
+ return internal::StringToIntImpl(input, *output);
}
bool StringToInt(StringPiece16 input, int* output) {
- return String16ToIntImpl(input, output);
+ return internal::StringToIntImpl(input, *output);
}
bool StringToUint(StringPiece input, unsigned* output) {
- return StringToIntImpl(input, output);
+ return internal::StringToIntImpl(input, *output);
}
bool StringToUint(StringPiece16 input, unsigned* output) {
- return String16ToIntImpl(input, output);
+ return internal::StringToIntImpl(input, *output);
}
bool StringToInt64(StringPiece input, int64_t* output) {
- return StringToIntImpl(input, output);
+ return internal::StringToIntImpl(input, *output);
}
bool StringToInt64(StringPiece16 input, int64_t* output) {
- return String16ToIntImpl(input, output);
+ return internal::StringToIntImpl(input, *output);
}
bool StringToUint64(StringPiece input, uint64_t* output) {
- return StringToIntImpl(input, output);
+ return internal::StringToIntImpl(input, *output);
}
bool StringToUint64(StringPiece16 input, uint64_t* output) {
- return String16ToIntImpl(input, output);
+ return internal::StringToIntImpl(input, *output);
}
bool StringToSizeT(StringPiece input, size_t* output) {
- return StringToIntImpl(input, output);
+ return internal::StringToIntImpl(input, *output);
}
bool StringToSizeT(StringPiece16 input, size_t* output) {
- return String16ToIntImpl(input, output);
-}
-
-template <typename STRING, typename CHAR>
-bool StringToDoubleImpl(STRING input, const CHAR* data, double* output) {
- static NoDestructor<double_conversion::StringToDoubleConverter> converter(
- double_conversion::StringToDoubleConverter::ALLOW_LEADING_SPACES |
- double_conversion::StringToDoubleConverter::ALLOW_TRAILING_JUNK,
- 0.0, 0, nullptr, nullptr);
-
- int processed_characters_count;
- *output = converter->StringToDouble(data, input.size(),
- &processed_characters_count);
-
- // Cases to return false:
- // - If the input string is empty, there was nothing to parse.
- // - If the value saturated to HUGE_VAL.
- // - If the entire string was not processed, there are either characters
- // remaining in the string after a parsed number, or the string does not
- // begin with a parseable number.
- // - If the first character is a space, there was leading whitespace
- return !input.empty() && *output != HUGE_VAL && *output != -HUGE_VAL &&
- static_cast<size_t>(processed_characters_count) == input.size() &&
- !IsUnicodeWhitespace(input[0]);
+ return internal::StringToIntImpl(input, *output);
}
bool StringToDouble(StringPiece input, double* output) {
- return StringToDoubleImpl(input, input.data(), output);
+ return internal::StringToDoubleImpl(input, input.data(), *output);
}
bool StringToDouble(StringPiece16 input, double* output) {
- return StringToDoubleImpl(
- input, reinterpret_cast<const uint16_t*>(input.data()), output);
+ return internal::StringToDoubleImpl(
+ input, reinterpret_cast<const uint16_t*>(input.data()), *output);
}
std::string HexEncode(const void* bytes, size_t size) {
@@ -477,69 +139,36 @@
}
bool HexStringToInt(StringPiece input, int* output) {
- return IteratorRangeToNumber<HexIteratorRangeToIntTraits>::Invoke(
- input.begin(), input.end(), output);
+ return internal::HexStringToIntImpl(input, *output);
}
bool HexStringToUInt(StringPiece input, uint32_t* output) {
- return IteratorRangeToNumber<HexIteratorRangeToUIntTraits>::Invoke(
- input.begin(), input.end(), output);
+ return internal::HexStringToIntImpl(input, *output);
}
bool HexStringToInt64(StringPiece input, int64_t* output) {
- return IteratorRangeToNumber<HexIteratorRangeToInt64Traits>::Invoke(
- input.begin(), input.end(), output);
+ return internal::HexStringToIntImpl(input, *output);
}
bool HexStringToUInt64(StringPiece input, uint64_t* output) {
- return IteratorRangeToNumber<HexIteratorRangeToUInt64Traits>::Invoke(
- input.begin(), input.end(), output);
-}
-
-template <typename Container>
-static bool HexStringToByteContainer(StringPiece input, Container* output) {
- GURL_DCHECK_EQ(output->size(), 0u);
- size_t count = input.size();
- if (count == 0 || (count % 2) != 0)
- return false;
- for (uintptr_t i = 0; i < count / 2; ++i) {
- uint8_t msb = 0; // most significant 4 bits
- uint8_t lsb = 0; // least significant 4 bits
- if (!CharToDigit<16>(input[i * 2], &msb) ||
- !CharToDigit<16>(input[i * 2 + 1], &lsb)) {
- return false;
- }
- output->push_back((msb << 4) | lsb);
- }
- return true;
+ return internal::HexStringToIntImpl(input, *output);
}
bool HexStringToBytes(StringPiece input, std::vector<uint8_t>* output) {
- return HexStringToByteContainer(input, output);
+ GURL_DCHECK(output->empty());
+ return internal::HexStringToByteContainer(input, std::back_inserter(*output));
}
bool HexStringToString(StringPiece input, std::string* output) {
- return HexStringToByteContainer(input, output);
+ GURL_DCHECK(output->empty());
+ return internal::HexStringToByteContainer(input, std::back_inserter(*output));
}
bool HexStringToSpan(StringPiece input, gurl_base::span<uint8_t> output) {
- size_t count = input.size();
- if (count == 0 || (count % 2) != 0)
+ if (input.size() / 2 != output.size())
return false;
- if (count / 2 != output.size())
- return false;
-
- for (uintptr_t i = 0; i < count / 2; ++i) {
- uint8_t msb = 0; // most significant 4 bits
- uint8_t lsb = 0; // least significant 4 bits
- if (!CharToDigit<16>(input[i * 2], &msb) ||
- !CharToDigit<16>(input[i * 2 + 1], &lsb)) {
- return false;
- }
- output[i] = (msb << 4) | lsb;
- }
- return true;
+ return internal::HexStringToByteContainer(input, output.begin());
}
} // namespace base
diff --git a/base/strings/string_number_conversions.h b/base/strings/string_number_conversions.h
index 872ead2..7bb51b6 100644
--- a/base/strings/string_number_conversions.h
+++ b/base/strings/string_number_conversions.h
@@ -20,10 +20,6 @@
// ----------------------------------------------------------------------------
// IMPORTANT MESSAGE FROM YOUR SPONSOR
//
-// This file contains no "wstring" variants. New code should use string16. If
-// you need to make old code work, use the UTF8 version and convert. Please do
-// not add wstring variants.
-//
// Please do not add "convenience" functions for converting strings to integers
// that return the value and ignore success/failure. That encourages people to
// write code that doesn't properly handle the error conditions.
@@ -154,4 +150,8 @@
} // namespace base
+#if defined(OS_WIN)
+#include "base/strings/string_number_conversions_win.h"
+#endif
+
#endif // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
diff --git a/base/strings/string_number_conversions_internal.h b/base/strings/string_number_conversions_internal.h
new file mode 100644
index 0000000..4f917f8
--- /dev/null
+++ b/base/strings/string_number_conversions_internal.h
@@ -0,0 +1,303 @@
+// Copyright 2020 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_STRINGS_STRING_NUMBER_CONVERSIONS_INTERNAL_H_
+#define BASE_STRINGS_STRING_NUMBER_CONVERSIONS_INTERNAL_H_
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <wctype.h>
+
+#include <limits>
+
+#include "polyfills/base/check_op.h"
+#include "polyfills/base/logging.h"
+#include "base/no_destructor.h"
+#include "base/numerics/safe_math.h"
+#include "base/strings/string_util.h"
+#include "base/third_party/double_conversion/double-conversion/double-conversion.h"
+
+namespace gurl_base {
+
+namespace internal {
+
+template <typename STR, typename INT>
+static STR IntToStringT(INT value) {
+ // log10(2) ~= 0.3 bytes needed per bit or per byte log10(2**8) ~= 2.4.
+ // So round up to allocate 3 output characters per byte, plus 1 for '-'.
+ const size_t kOutputBufSize =
+ 3 * sizeof(INT) + std::numeric_limits<INT>::is_signed;
+
+ // Create the string in a temporary buffer, write it back to front, and
+ // then return the substr of what we ended up using.
+ using CHR = typename STR::value_type;
+ CHR outbuf[kOutputBufSize];
+
+ // The ValueOrDie call below can never fail, because UnsignedAbs is valid
+ // for all valid inputs.
+ std::make_unsigned_t<INT> res =
+ CheckedNumeric<INT>(value).UnsignedAbs().ValueOrDie();
+
+ CHR* end = outbuf + kOutputBufSize;
+ CHR* i = end;
+ do {
+ --i;
+ GURL_DCHECK(i != outbuf);
+ *i = static_cast<CHR>((res % 10) + '0');
+ res /= 10;
+ } while (res != 0);
+ if (IsValueNegative(value)) {
+ --i;
+ GURL_DCHECK(i != outbuf);
+ *i = static_cast<CHR>('-');
+ }
+ return STR(i, end);
+}
+
+// Utility to convert a character to a digit in a given base
+template <int BASE, typename CHAR>
+Optional<uint8_t> CharToDigit(CHAR c) {
+ static_assert(1 <= BASE && BASE <= 36, "BASE needs to be in [1, 36]");
+ if (c >= '0' && c < '0' + std::min(BASE, 10))
+ return c - '0';
+
+ if (c >= 'a' && c < 'a' + BASE - 10)
+ return c - 'a' + 10;
+
+ if (c >= 'A' && c < 'A' + BASE - 10)
+ return c - 'A' + 10;
+
+ return gurl_base::nullopt;
+}
+
+// There is an IsUnicodeWhitespace for wchars defined in string_util.h, but it
+// is locale independent, whereas the functions we are replacing were
+// locale-dependent. TBD what is desired, but for the moment let's not
+// introduce a change in behaviour.
+template <typename CHAR>
+class WhitespaceHelper {};
+
+template <>
+class WhitespaceHelper<char> {
+ public:
+ static bool Invoke(char c) {
+ return 0 != isspace(static_cast<unsigned char>(c));
+ }
+};
+
+template <>
+class WhitespaceHelper<char16> {
+ public:
+ static bool Invoke(char16 c) { return 0 != iswspace(c); }
+};
+
+template <typename CHAR>
+bool LocalIsWhitespace(CHAR c) {
+ return WhitespaceHelper<CHAR>::Invoke(c);
+}
+
+template <typename Number, int kBase>
+class StringToNumberParser {
+ public:
+ struct Result {
+ Number value = 0;
+ bool valid = false;
+ };
+
+ static constexpr Number kMin = std::numeric_limits<Number>::min();
+ static constexpr Number kMax = std::numeric_limits<Number>::max();
+
+ // Sign provides:
+ // - a static function, CheckBounds, that determines whether the next digit
+ // causes an overflow/underflow
+ // - a static function, Increment, that appends the next digit appropriately
+ // according to the sign of the number being parsed.
+ template <typename Sign>
+ class Base {
+ public:
+ template <typename Iter>
+ static Result Invoke(Iter begin, Iter end) {
+ Number value = 0;
+
+ if (begin == end) {
+ return {value, false};
+ }
+
+ // Note: no performance difference was found when using template
+ // specialization to remove this check in bases other than 16
+ if (kBase == 16 && end - begin > 2 && *begin == '0' &&
+ (*(begin + 1) == 'x' || *(begin + 1) == 'X')) {
+ begin += 2;
+ }
+
+ for (Iter current = begin; current != end; ++current) {
+ Optional<uint8_t> new_digit = CharToDigit<kBase>(*current);
+
+ if (!new_digit) {
+ return {value, false};
+ }
+
+ if (current != begin) {
+ Result result = Sign::CheckBounds(value, *new_digit);
+ if (!result.valid)
+ return result;
+
+ value *= kBase;
+ }
+
+ value = Sign::Increment(value, *new_digit);
+ }
+ return {value, true};
+ }
+ };
+
+ class Positive : public Base<Positive> {
+ public:
+ static Result CheckBounds(Number value, uint8_t new_digit) {
+ if (value > static_cast<Number>(kMax / kBase) ||
+ (value == static_cast<Number>(kMax / kBase) &&
+ new_digit > kMax % kBase)) {
+ return {kMax, false};
+ }
+ return {value, true};
+ }
+ static Number Increment(Number lhs, uint8_t rhs) { return lhs + rhs; }
+ };
+
+ class Negative : public Base<Negative> {
+ public:
+ static Result CheckBounds(Number value, uint8_t new_digit) {
+ if (value < kMin / kBase ||
+ (value == kMin / kBase && new_digit > 0 - kMin % kBase)) {
+ return {kMin, false};
+ }
+ return {value, true};
+ }
+ static Number Increment(Number lhs, uint8_t rhs) { return lhs - rhs; }
+ };
+};
+
+template <typename Number, int kBase, typename Str>
+auto StringToNumber(BasicStringPiece<Str> input) {
+ using Parser = StringToNumberParser<Number, kBase>;
+ using Result = typename Parser::Result;
+
+ bool has_leading_whitespace = false;
+ auto begin = input.begin();
+ auto end = input.end();
+
+ while (begin != end && LocalIsWhitespace(*begin)) {
+ has_leading_whitespace = true;
+ ++begin;
+ }
+
+ if (begin != end && *begin == '-') {
+ if (!std::numeric_limits<Number>::is_signed) {
+ return Result{0, false};
+ }
+
+ Result result = Parser::Negative::Invoke(begin + 1, end);
+ result.valid &= !has_leading_whitespace;
+ return result;
+ }
+
+ if (begin != end && *begin == '+') {
+ ++begin;
+ }
+
+ Result result = Parser::Positive::Invoke(begin, end);
+ result.valid &= !has_leading_whitespace;
+ return result;
+}
+
+template <typename STR, typename VALUE>
+bool StringToIntImpl(BasicStringPiece<STR> input, VALUE& output) {
+ auto result = StringToNumber<VALUE, 10>(input);
+ output = result.value;
+ return result.valid;
+}
+
+template <typename STR, typename VALUE>
+bool HexStringToIntImpl(BasicStringPiece<STR> input, VALUE& output) {
+ auto result = StringToNumber<VALUE, 16>(input);
+ output = result.value;
+ return result.valid;
+}
+
+static const double_conversion::DoubleToStringConverter*
+GetDoubleToStringConverter() {
+ static NoDestructor<double_conversion::DoubleToStringConverter> converter(
+ double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN,
+ nullptr, nullptr, 'e', -6, 12, 0, 0);
+ return converter.get();
+}
+
+// Converts a given (data, size) pair to a desired string type. For
+// performance reasons, this dispatches to a different constructor if the
+// passed-in data matches the string's value_type.
+template <typename StringT>
+StringT ToString(const typename StringT::value_type* data, size_t size) {
+ return StringT(data, size);
+}
+
+template <typename StringT, typename CharT>
+StringT ToString(const CharT* data, size_t size) {
+ return StringT(data, data + size);
+}
+
+template <typename StringT>
+StringT DoubleToStringT(double value) {
+ char buffer[32];
+ double_conversion::StringBuilder builder(buffer, sizeof(buffer));
+ GetDoubleToStringConverter()->ToShortest(value, &builder);
+ return ToString<StringT>(buffer, builder.position());
+}
+
+template <typename STRING, typename CHAR>
+bool StringToDoubleImpl(STRING input, const CHAR* data, double& output) {
+ static NoDestructor<double_conversion::StringToDoubleConverter> converter(
+ double_conversion::StringToDoubleConverter::ALLOW_LEADING_SPACES |
+ double_conversion::StringToDoubleConverter::ALLOW_TRAILING_JUNK,
+ 0.0, 0, nullptr, nullptr);
+
+ int processed_characters_count;
+ output = converter->StringToDouble(data, input.size(),
+ &processed_characters_count);
+
+ // Cases to return false:
+ // - If the input string is empty, there was nothing to parse.
+ // - If the value saturated to HUGE_VAL.
+ // - If the entire string was not processed, there are either characters
+ // remaining in the string after a parsed number, or the string does not
+ // begin with a parseable number.
+ // - If the first character is a space, there was leading whitespace
+ return !input.empty() && output != HUGE_VAL && output != -HUGE_VAL &&
+ static_cast<size_t>(processed_characters_count) == input.size() &&
+ !IsUnicodeWhitespace(input[0]);
+}
+
+template <typename OutIter>
+static bool HexStringToByteContainer(StringPiece input, OutIter output) {
+ size_t count = input.size();
+ if (count == 0 || (count % 2) != 0)
+ return false;
+ for (uintptr_t i = 0; i < count / 2; ++i) {
+ // most significant 4 bits
+ Optional<uint8_t> msb = CharToDigit<16>(input[i * 2]);
+ // least significant 4 bits
+ Optional<uint8_t> lsb = CharToDigit<16>(input[i * 2 + 1]);
+ if (!msb || !lsb) {
+ return false;
+ }
+ *(output++) = (*msb << 4) | *lsb;
+ }
+ return true;
+}
+
+} // namespace internal
+
+} // namespace base
+
+#endif // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_INTERNAL_H_
diff --git a/base/strings/string_number_conversions_win.cc b/base/strings/string_number_conversions_win.cc
new file mode 100644
index 0000000..abae437
--- /dev/null
+++ b/base/strings/string_number_conversions_win.cc
@@ -0,0 +1,79 @@
+// Copyright 2020 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.
+
+#include "base/strings/string_number_conversions_win.h"
+
+#include <string>
+
+#include "base/strings/string_number_conversions_internal.h"
+#include "base/strings/string_piece.h"
+
+namespace gurl_base {
+
+std::wstring NumberToWString(int value) {
+ return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(unsigned value) {
+ return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(long value) {
+ return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(unsigned long value) {
+ return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(long long value) {
+ return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(unsigned long long value) {
+ return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(double value) {
+ return internal::DoubleToStringT<std::wstring>(value);
+}
+
+#if defined(BASE_STRING16_IS_STD_U16STRING)
+namespace internal {
+
+template <>
+class WhitespaceHelper<wchar_t> {
+ public:
+ static bool Invoke(wchar_t c) { return 0 != iswspace(c); }
+};
+
+} // namespace internal
+
+bool StringToInt(WStringPiece input, int* output) {
+ return internal::StringToIntImpl(input, *output);
+}
+
+bool StringToUint(WStringPiece input, unsigned* output) {
+ return internal::StringToIntImpl(input, *output);
+}
+
+bool StringToInt64(WStringPiece input, int64_t* output) {
+ return internal::StringToIntImpl(input, *output);
+}
+
+bool StringToUint64(WStringPiece input, uint64_t* output) {
+ return internal::StringToIntImpl(input, *output);
+}
+
+bool StringToSizeT(WStringPiece input, size_t* output) {
+ return internal::StringToIntImpl(input, *output);
+}
+
+bool StringToDouble(WStringPiece input, double* output) {
+ return internal::StringToDoubleImpl(
+ input, reinterpret_cast<const uint16_t*>(input.data()), *output);
+}
+#endif // defined(BASE_STRING16_IS_STD_U16STRING)
+
+} // namespace base
diff --git a/base/strings/string_number_conversions_win.h b/base/strings/string_number_conversions_win.h
new file mode 100644
index 0000000..f8b645f
--- /dev/null
+++ b/base/strings/string_number_conversions_win.h
@@ -0,0 +1,40 @@
+// Copyright 2020 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_STRINGS_STRING_NUMBER_CONVERSIONS_WIN_H_
+#define BASE_STRINGS_STRING_NUMBER_CONVERSIONS_WIN_H_
+
+#include <string>
+
+#include "polyfills/base/base_export.h"
+#include "base/strings/string_piece.h"
+
+namespace gurl_base {
+
+BASE_EXPORT std::wstring NumberToWString(int value);
+BASE_EXPORT std::wstring NumberToWString(unsigned int value);
+BASE_EXPORT std::wstring NumberToWString(long value);
+BASE_EXPORT std::wstring NumberToWString(unsigned long value);
+BASE_EXPORT std::wstring NumberToWString(long long value);
+BASE_EXPORT std::wstring NumberToWString(unsigned long long value);
+BASE_EXPORT std::wstring NumberToWString(double value);
+
+// The following section contains overloads of the cross-platform APIs for
+// std::wstring and gurl_base::WStringPiece. These are only enabled if std::wstring
+// and gurl_base::string16 are distinct types, as otherwise this would result in an
+// ODR violation.
+// TODO(crbug.com/911896): Remove those guards once gurl_base::string16 is
+// std::u16string.
+#if defined(BASE_STRING16_IS_STD_U16STRING)
+BASE_EXPORT bool StringToInt(WStringPiece input, int* output);
+BASE_EXPORT bool StringToUint(WStringPiece input, unsigned* output);
+BASE_EXPORT bool StringToInt64(WStringPiece input, int64_t* output);
+BASE_EXPORT bool StringToUint64(WStringPiece input, uint64_t* output);
+BASE_EXPORT bool StringToSizeT(WStringPiece input, size_t* output);
+BASE_EXPORT bool StringToDouble(WStringPiece input, double* output);
+#endif // defined(BASE_STRING16_IS_STD_U16STRING)
+
+} // namespace base
+
+#endif // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_WIN_H_
diff --git a/base/strings/string_piece.cc b/base/strings/string_piece.cc
index 74f3335..ee043de 100644
--- a/base/strings/string_piece.cc
+++ b/base/strings/string_piece.cc
@@ -6,11 +6,11 @@
#include "base/strings/string_piece.h"
#include <limits.h>
+#include <string.h>
#include <algorithm>
#include <ostream>
-#include "polyfills/base/logging.h"
#include "base/strings/utf_string_conversions.h"
namespace gurl_base {
diff --git a/base/strings/string_piece.h b/base/strings/string_piece.h
index 964ec67..d155496 100644
--- a/base/strings/string_piece.h
+++ b/base/strings/string_piece.h
@@ -25,11 +25,12 @@
#include <stddef.h>
#include <iosfwd>
+#include <ostream>
#include <string>
#include <type_traits>
#include "polyfills/base/base_export.h"
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check_op.h"
#include "base/strings/char_traits.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece_forward.h"
@@ -148,6 +149,7 @@
public:
// Standard STL container boilerplate.
typedef size_t size_type;
+ typedef typename STRING_TYPE::traits_type traits_type;
typedef typename STRING_TYPE::value_type value_type;
typedef const value_type* pointer;
typedef const value_type& reference;
@@ -162,7 +164,7 @@
// We provide non-explicit singleton constructors so users can pass
// in a "const char*" or a "string" wherever a "StringPiece" is
// expected (likewise for char16, string16, StringPiece16).
- constexpr BasicStringPiece() : ptr_(NULL), length_(0) {}
+ constexpr BasicStringPiece() : ptr_(nullptr), length_(0) {}
// TODO(crbug.com/1049498): Construction from nullptr is not allowed for
// std::basic_string_view, so remove the special handling for it.
// Note: This doesn't just use STRING_TYPE::traits_type::length(), since that
diff --git a/base/strings/string_split.cc b/base/strings/string_split.cc
index 3816501..40dedb7 100644
--- a/base/strings/string_split.cc
+++ b/base/strings/string_split.cc
@@ -7,6 +7,7 @@
#include <stddef.h>
#include "polyfills/base/logging.h"
+#include "base/strings/string_split_internal.h"
#include "base/strings/string_util.h"
#include "base/third_party/icu/icu_utf.h"
@@ -14,56 +15,6 @@
namespace {
-// Returns either the ASCII or UTF-16 whitespace.
-template<typename Str> BasicStringPiece<Str> WhitespaceForType();
-#if defined(OS_WIN) && defined(BASE_STRING16_IS_STD_U16STRING)
-template <>
-WStringPiece WhitespaceForType<std::wstring>() {
- return kWhitespaceWide;
-}
-#endif
-
-template<> StringPiece16 WhitespaceForType<string16>() {
- return kWhitespaceUTF16;
-}
-template<> StringPiece WhitespaceForType<std::string>() {
- return kWhitespaceASCII;
-}
-
-// General string splitter template. Can take 8- or 16-bit input, can produce
-// the corresponding string or StringPiece output.
-template <typename OutputStringType, typename Str>
-static std::vector<OutputStringType> SplitStringT(
- BasicStringPiece<Str> str,
- BasicStringPiece<Str> delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type) {
- std::vector<OutputStringType> result;
- if (str.empty())
- return result;
-
- size_t start = 0;
- while (start != Str::npos) {
- size_t end = str.find_first_of(delimiter, start);
-
- BasicStringPiece<Str> piece;
- if (end == Str::npos) {
- piece = str.substr(start);
- start = Str::npos;
- } else {
- piece = str.substr(start, end - start);
- start = end + 1;
- }
-
- if (whitespace == TRIM_WHITESPACE)
- piece = TrimString(piece, WhitespaceForType<Str>(), TRIM_ALL);
-
- if (result_type == SPLIT_WANT_ALL || !piece.empty())
- result.emplace_back(piece);
- }
- return result;
-}
-
bool AppendStringKeyValue(StringPiece input,
char delimiter,
StringPairs* result) {
@@ -94,62 +45,38 @@
return true;
}
-template <typename OutputStringType, typename Str>
-std::vector<OutputStringType> SplitStringUsingSubstrT(
- BasicStringPiece<Str> input,
- BasicStringPiece<Str> delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type) {
- using Piece = BasicStringPiece<Str>;
- using size_type = typename Piece::size_type;
-
- std::vector<OutputStringType> result;
- for (size_type begin_index = 0, end_index = 0; end_index != Piece::npos;
- begin_index = end_index + delimiter.size()) {
- end_index = input.find(delimiter, begin_index);
- Piece term = end_index == Piece::npos
- ? input.substr(begin_index)
- : input.substr(begin_index, end_index - begin_index);
-
- if (whitespace == TRIM_WHITESPACE)
- term = TrimString(term, WhitespaceForType<Str>(), TRIM_ALL);
-
- if (result_type == SPLIT_WANT_ALL || !term.empty())
- result.emplace_back(term);
- }
-
- return result;
-}
-
} // namespace
std::vector<std::string> SplitString(StringPiece input,
StringPiece separators,
WhitespaceHandling whitespace,
SplitResult result_type) {
- return SplitStringT<std::string>(input, separators, whitespace, result_type);
+ return internal::SplitStringT<std::string>(input, separators, whitespace,
+ result_type);
}
std::vector<string16> SplitString(StringPiece16 input,
StringPiece16 separators,
WhitespaceHandling whitespace,
SplitResult result_type) {
- return SplitStringT<string16>(input, separators, whitespace, result_type);
+ return internal::SplitStringT<string16>(input, separators, whitespace,
+ result_type);
}
std::vector<StringPiece> SplitStringPiece(StringPiece input,
StringPiece separators,
WhitespaceHandling whitespace,
SplitResult result_type) {
- return SplitStringT<StringPiece>(input, separators, whitespace, result_type);
+ return internal::SplitStringT<StringPiece>(input, separators, whitespace,
+ result_type);
}
std::vector<StringPiece16> SplitStringPiece(StringPiece16 input,
StringPiece16 separators,
WhitespaceHandling whitespace,
SplitResult result_type) {
- return SplitStringT<StringPiece16>(input, separators, whitespace,
- result_type);
+ return internal::SplitStringT<StringPiece16>(input, separators, whitespace,
+ result_type);
}
bool SplitStringIntoKeyValuePairs(StringPiece input,
@@ -187,16 +114,16 @@
StringPiece16 delimiter,
WhitespaceHandling whitespace,
SplitResult result_type) {
- return SplitStringUsingSubstrT<string16>(input, delimiter, whitespace,
- result_type);
+ return internal::SplitStringUsingSubstrT<string16>(input, delimiter,
+ whitespace, result_type);
}
std::vector<std::string> SplitStringUsingSubstr(StringPiece input,
StringPiece delimiter,
WhitespaceHandling whitespace,
SplitResult result_type) {
- return SplitStringUsingSubstrT<std::string>(input, delimiter, whitespace,
- result_type);
+ return internal::SplitStringUsingSubstrT<std::string>(
+ input, delimiter, whitespace, result_type);
}
std::vector<StringPiece16> SplitStringPieceUsingSubstr(
@@ -205,8 +132,8 @@
WhitespaceHandling whitespace,
SplitResult result_type) {
std::vector<StringPiece16> result;
- return SplitStringUsingSubstrT<StringPiece16>(input, delimiter, whitespace,
- result_type);
+ return internal::SplitStringUsingSubstrT<StringPiece16>(
+ input, delimiter, whitespace, result_type);
}
std::vector<StringPiece> SplitStringPieceUsingSubstr(
@@ -214,41 +141,8 @@
StringPiece delimiter,
WhitespaceHandling whitespace,
SplitResult result_type) {
- return SplitStringUsingSubstrT<StringPiece>(input, delimiter, whitespace,
- result_type);
+ return internal::SplitStringUsingSubstrT<StringPiece>(
+ input, delimiter, whitespace, result_type);
}
-#if defined(OS_WIN) && defined(BASE_STRING16_IS_STD_U16STRING)
-std::vector<std::wstring> SplitString(WStringPiece input,
- WStringPiece separators,
- WhitespaceHandling whitespace,
- SplitResult result_type) {
- return SplitStringT<std::wstring>(input, separators, whitespace, result_type);
-}
-
-std::vector<WStringPiece> SplitStringPiece(WStringPiece input,
- WStringPiece separators,
- WhitespaceHandling whitespace,
- SplitResult result_type) {
- return SplitStringT<WStringPiece>(input, separators, whitespace, result_type);
-}
-
-std::vector<std::wstring> SplitStringUsingSubstr(WStringPiece input,
- WStringPiece delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type) {
- return SplitStringUsingSubstrT<std::wstring>(input, delimiter, whitespace,
- result_type);
-}
-
-std::vector<WStringPiece> SplitStringPieceUsingSubstr(
- WStringPiece input,
- WStringPiece delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type) {
- return SplitStringUsingSubstrT<WStringPiece>(input, delimiter, whitespace,
- result_type);
-}
-#endif
-
} // namespace base
diff --git a/base/strings/string_split.h b/base/strings/string_split.h
index 02c2c59..d9676c7 100644
--- a/base/strings/string_split.h
+++ b/base/strings/string_split.h
@@ -138,32 +138,10 @@
WhitespaceHandling whitespace,
SplitResult result_type) WARN_UNUSED_RESULT;
-#if defined(OS_WIN) && defined(BASE_STRING16_IS_STD_U16STRING)
-BASE_EXPORT std::vector<std::wstring> SplitString(WStringPiece input,
- WStringPiece separators,
- WhitespaceHandling whitespace,
- SplitResult result_type)
- WARN_UNUSED_RESULT;
-
-BASE_EXPORT std::vector<WStringPiece> SplitStringPiece(
- WStringPiece input,
- WStringPiece separators,
- WhitespaceHandling whitespace,
- SplitResult result_type) WARN_UNUSED_RESULT;
-
-BASE_EXPORT std::vector<std::wstring> SplitStringUsingSubstr(
- WStringPiece input,
- WStringPiece delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type) WARN_UNUSED_RESULT;
-
-BASE_EXPORT std::vector<WStringPiece> SplitStringPieceUsingSubstr(
- WStringPiece input,
- WStringPiece delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type) WARN_UNUSED_RESULT;
-#endif
-
} // namespace base
+#if defined(OS_WIN)
+#include "base/strings/string_split_win.h"
+#endif
+
#endif // BASE_STRINGS_STRING_SPLIT_H_
diff --git a/base/strings/string_split_internal.h b/base/strings/string_split_internal.h
new file mode 100644
index 0000000..9dc3763
--- /dev/null
+++ b/base/strings/string_split_internal.h
@@ -0,0 +1,100 @@
+// Copyright 2020 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_STRINGS_STRING_SPLIT_INTERNAL_H_
+#define BASE_STRINGS_STRING_SPLIT_INTERNAL_H_
+
+#include <vector>
+
+#include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
+
+namespace gurl_base {
+
+namespace internal {
+
+// Returns either the ASCII or UTF-16 whitespace.
+template <typename Str>
+BasicStringPiece<Str> WhitespaceForType();
+
+template <>
+inline StringPiece16 WhitespaceForType<string16>() {
+ return kWhitespaceUTF16;
+}
+template <>
+inline StringPiece WhitespaceForType<std::string>() {
+ return kWhitespaceASCII;
+}
+
+// General string splitter template. Can take 8- or 16-bit input, can produce
+// the corresponding string or StringPiece output.
+template <typename OutputStringType, typename Str>
+static std::vector<OutputStringType> SplitStringT(
+ BasicStringPiece<Str> str,
+ BasicStringPiece<Str> delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
+ std::vector<OutputStringType> result;
+ if (str.empty())
+ return result;
+
+ size_t start = 0;
+ while (start != Str::npos) {
+ size_t end = str.find_first_of(delimiter, start);
+
+ BasicStringPiece<Str> piece;
+ if (end == Str::npos) {
+ piece = str.substr(start);
+ start = Str::npos;
+ } else {
+ piece = str.substr(start, end - start);
+ start = end + 1;
+ }
+
+ if (whitespace == TRIM_WHITESPACE)
+ piece = TrimString(piece, WhitespaceForType<Str>(), TRIM_ALL);
+
+ if (result_type == SPLIT_WANT_ALL || !piece.empty())
+ result.emplace_back(piece);
+ }
+ return result;
+}
+
+template <typename OutputStringType, typename Str>
+std::vector<OutputStringType> SplitStringUsingSubstrT(
+ BasicStringPiece<Str> input,
+ BasicStringPiece<Str> delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
+ using Piece = BasicStringPiece<Str>;
+ using size_type = typename Piece::size_type;
+
+ std::vector<OutputStringType> result;
+ if (delimiter.size() == 0) {
+ result.emplace_back(input);
+ return result;
+ }
+
+ for (size_type begin_index = 0, end_index = 0; end_index != Piece::npos;
+ begin_index = end_index + delimiter.size()) {
+ end_index = input.find(delimiter, begin_index);
+ Piece term = end_index == Piece::npos
+ ? input.substr(begin_index)
+ : input.substr(begin_index, end_index - begin_index);
+
+ if (whitespace == TRIM_WHITESPACE)
+ term = TrimString(term, WhitespaceForType<Str>(), TRIM_ALL);
+
+ if (result_type == SPLIT_WANT_ALL || !term.empty())
+ result.emplace_back(term);
+ }
+
+ return result;
+}
+
+} // namespace internal
+
+} // namespace base
+
+#endif // BASE_STRINGS_STRING_SPLIT_INTERNAL_H_
diff --git a/base/strings/string_split_unittest.cc b/base/strings/string_split_unittest.cc
index f84d4b8..a3e13fa 100644
--- a/base/strings/string_split_unittest.cc
+++ b/base/strings/string_split_unittest.cc
@@ -218,6 +218,13 @@
EXPECT_THAT(results, ElementsAre(""));
}
+TEST(SplitStringUsingSubstrTest, EmptyDelimiter) {
+ std::vector<std::string> results = SplitStringUsingSubstr(
+ "TEST", std::string(), TRIM_WHITESPACE, SPLIT_WANT_ALL);
+ ASSERT_EQ(1u, results.size());
+ EXPECT_THAT(results, ElementsAre("TEST"));
+}
+
TEST(StringUtilTest, SplitString_Basics) {
std::vector<std::string> r;
diff --git a/base/strings/string_split_win.cc b/base/strings/string_split_win.cc
new file mode 100644
index 0000000..297853c
--- /dev/null
+++ b/base/strings/string_split_win.cc
@@ -0,0 +1,59 @@
+// Copyright 2020 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.
+
+#include "base/strings/string_split_win.h"
+
+#include <string>
+#include <vector>
+
+#include "base/strings/string_piece.h"
+#include "base/strings/string_split_internal.h"
+
+namespace gurl_base {
+
+#if defined(BASE_STRING16_IS_STD_U16STRING)
+namespace internal {
+
+template <>
+inline WStringPiece WhitespaceForType<std::wstring>() {
+ return kWhitespaceWide;
+}
+
+} // namespace internal
+
+std::vector<std::wstring> SplitString(WStringPiece input,
+ WStringPiece separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
+ return internal::SplitStringT<std::wstring>(input, separators, whitespace,
+ result_type);
+}
+
+std::vector<WStringPiece> SplitStringPiece(WStringPiece input,
+ WStringPiece separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
+ return internal::SplitStringT<WStringPiece>(input, separators, whitespace,
+ result_type);
+}
+
+std::vector<std::wstring> SplitStringUsingSubstr(WStringPiece input,
+ WStringPiece delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
+ return internal::SplitStringUsingSubstrT<std::wstring>(
+ input, delimiter, whitespace, result_type);
+}
+
+std::vector<WStringPiece> SplitStringPieceUsingSubstr(
+ WStringPiece input,
+ WStringPiece delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
+ return internal::SplitStringUsingSubstrT<WStringPiece>(
+ input, delimiter, whitespace, result_type);
+}
+#endif
+
+} // namespace base
diff --git a/base/strings/string_split_win.h b/base/strings/string_split_win.h
new file mode 100644
index 0000000..080641c
--- /dev/null
+++ b/base/strings/string_split_win.h
@@ -0,0 +1,53 @@
+// Copyright 2020 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_STRINGS_STRING_SPLIT_WIN_H_
+#define BASE_STRINGS_STRING_SPLIT_WIN_H_
+
+#include <string>
+#include <vector>
+
+#include "polyfills/base/base_export.h"
+#include "base/compiler_specific.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_split.h"
+
+namespace gurl_base {
+
+// The following section contains overloads of the cross-platform APIs for
+// std::wstring and gurl_base::WStringPiece. These are only enabled if std::wstring
+// and gurl_base::string16 are distinct types, as otherwise this would result in an
+// ODR violation.
+// TODO(crbug.com/911896): Remove those guards once gurl_base::string16 is
+// std::u16string.
+#if defined(BASE_STRING16_IS_STD_U16STRING)
+BASE_EXPORT std::vector<std::wstring> SplitString(WStringPiece input,
+ WStringPiece separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type)
+ WARN_UNUSED_RESULT;
+
+BASE_EXPORT std::vector<WStringPiece> SplitStringPiece(
+ WStringPiece input,
+ WStringPiece separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) WARN_UNUSED_RESULT;
+
+BASE_EXPORT std::vector<std::wstring> SplitStringUsingSubstr(
+ WStringPiece input,
+ WStringPiece delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) WARN_UNUSED_RESULT;
+
+BASE_EXPORT std::vector<WStringPiece> SplitStringPieceUsingSubstr(
+ WStringPiece input,
+ WStringPiece delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) WARN_UNUSED_RESULT;
+#endif
+
+} // namespace base
+
+#endif // BASE_STRINGS_STRING_SPLIT_WIN_H_
diff --git a/base/strings/string_util.cc b/base/strings/string_util.cc
index 742319a..c2e440f 100644
--- a/base/strings/string_util.cc
+++ b/base/strings/string_util.cc
@@ -18,11 +18,13 @@
#include <algorithm>
#include <limits>
+#include <type_traits>
#include <vector>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check_op.h"
#include "base/no_destructor.h"
#include "base/stl_util.h"
+#include "base/strings/string_util_internal.h"
#include "base/strings/utf_string_conversion_utils.h"
#include "base/strings/utf_string_conversions.h"
#include "base/third_party/icu/icu_utf.h"
@@ -30,60 +32,6 @@
namespace gurl_base {
-namespace {
-
-// Used by ReplaceStringPlaceholders to track the position in the string of
-// replaced parameters.
-struct ReplacementOffset {
- ReplacementOffset(uintptr_t parameter, size_t offset)
- : parameter(parameter),
- offset(offset) {}
-
- // Index of the parameter.
- uintptr_t parameter;
-
- // Starting position in the string.
- size_t offset;
-};
-
-static bool CompareParameter(const ReplacementOffset& elem1,
- const ReplacementOffset& elem2) {
- return elem1.parameter < elem2.parameter;
-}
-
-// Assuming that a pointer is the size of a "machine word", then
-// uintptr_t is an integer type that is also a machine word.
-using MachineWord = uintptr_t;
-
-inline bool IsMachineWordAligned(const void* pointer) {
- return !(reinterpret_cast<MachineWord>(pointer) & (sizeof(MachineWord) - 1));
-}
-
-template <typename CharacterType>
-struct NonASCIIMask;
-template <>
-struct NonASCIIMask<char> {
- static constexpr MachineWord value() {
- return static_cast<MachineWord>(0x8080808080808080ULL);
- }
-};
-template <>
-struct NonASCIIMask<char16> {
- static constexpr MachineWord value() {
- return static_cast<MachineWord>(0xFF80FF80FF80FF80ULL);
- }
-};
-#if defined(WCHAR_T_IS_UTF32)
-template <>
-struct NonASCIIMask<wchar_t> {
- static constexpr MachineWord value() {
- return static_cast<MachineWord>(0xFFFFFF80FFFFFF80ULL);
- }
-};
-#endif // WCHAR_T_IS_UTF32
-
-} // namespace
-
bool IsWprintfFormatPortable(const wchar_t* format) {
for (const wchar_t* position = format; *position != '\0'; ++position) {
if (*position == '%') {
@@ -119,89 +67,38 @@
return true;
}
-namespace {
-
-template<typename StringType>
-StringType ToLowerASCIIImpl(BasicStringPiece<StringType> str) {
- StringType ret;
- ret.reserve(str.size());
- for (size_t i = 0; i < str.size(); i++)
- ret.push_back(ToLowerASCII(str[i]));
- return ret;
-}
-
-template<typename StringType>
-StringType ToUpperASCIIImpl(BasicStringPiece<StringType> str) {
- StringType ret;
- ret.reserve(str.size());
- for (size_t i = 0; i < str.size(); i++)
- ret.push_back(ToUpperASCII(str[i]));
- return ret;
-}
-
-} // namespace
-
std::string ToLowerASCII(StringPiece str) {
- return ToLowerASCIIImpl<std::string>(str);
+ return internal::ToLowerASCIIImpl(str);
}
string16 ToLowerASCII(StringPiece16 str) {
- return ToLowerASCIIImpl<string16>(str);
+ return internal::ToLowerASCIIImpl(str);
}
std::string ToUpperASCII(StringPiece str) {
- return ToUpperASCIIImpl<std::string>(str);
+ return internal::ToUpperASCIIImpl(str);
}
string16 ToUpperASCII(StringPiece16 str) {
- return ToUpperASCIIImpl<string16>(str);
-}
-
-template<class StringType>
-int CompareCaseInsensitiveASCIIT(BasicStringPiece<StringType> a,
- BasicStringPiece<StringType> b) {
- // Find the first characters that aren't equal and compare them. If the end
- // of one of the strings is found before a nonequal character, the lengths
- // of the strings are compared.
- size_t i = 0;
- while (i < a.length() && i < b.length()) {
- typename StringType::value_type lower_a = ToLowerASCII(a[i]);
- typename StringType::value_type lower_b = ToLowerASCII(b[i]);
- if (lower_a < lower_b)
- return -1;
- if (lower_a > lower_b)
- return 1;
- i++;
- }
-
- // End of one string hit before finding a different character. Expect the
- // common case to be "strings equal" at this point so check that first.
- if (a.length() == b.length())
- return 0;
-
- if (a.length() < b.length())
- return -1;
- return 1;
+ return internal::ToUpperASCIIImpl(str);
}
int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b) {
- return CompareCaseInsensitiveASCIIT<std::string>(a, b);
+ return internal::CompareCaseInsensitiveASCIIT(a, b);
}
int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
- return CompareCaseInsensitiveASCIIT<string16>(a, b);
+ return internal::CompareCaseInsensitiveASCIIT(a, b);
}
bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b) {
- if (a.length() != b.length())
- return false;
- return CompareCaseInsensitiveASCIIT<std::string>(a, b) == 0;
+ return a.size() == b.size() &&
+ internal::CompareCaseInsensitiveASCIIT(a, b) == 0;
}
bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
- if (a.length() != b.length())
- return false;
- return CompareCaseInsensitiveASCIIT<string16>(a, b) == 0;
+ return a.size() == b.size() &&
+ internal::CompareCaseInsensitiveASCIIT(a, b) == 0;
}
const std::string& EmptyString() {
@@ -214,107 +111,56 @@
return *s16;
}
-template <class StringType>
-bool ReplaceCharsT(const StringType& input,
- BasicStringPiece<StringType> find_any_of_these,
- BasicStringPiece<StringType> replace_with,
- StringType* output);
-
-bool ReplaceChars(const string16& input,
+bool ReplaceChars(StringPiece16 input,
StringPiece16 replace_chars,
StringPiece16 replace_with,
string16* output) {
- return ReplaceCharsT(input, replace_chars, replace_with, output);
+ return internal::ReplaceCharsT(input, replace_chars, replace_with, output);
}
-bool ReplaceChars(const std::string& input,
+bool ReplaceChars(StringPiece input,
StringPiece replace_chars,
StringPiece replace_with,
std::string* output) {
- return ReplaceCharsT(input, replace_chars, replace_with, output);
+ return internal::ReplaceCharsT(input, replace_chars, replace_with, output);
}
-bool RemoveChars(const string16& input,
+bool RemoveChars(StringPiece16 input,
StringPiece16 remove_chars,
string16* output) {
- return ReplaceCharsT(input, remove_chars, StringPiece16(), output);
+ return internal::ReplaceCharsT(input, remove_chars, StringPiece16(), output);
}
-bool RemoveChars(const std::string& input,
+bool RemoveChars(StringPiece input,
StringPiece remove_chars,
std::string* output) {
- return ReplaceCharsT(input, remove_chars, StringPiece(), output);
-}
-
-template <typename Str>
-TrimPositions TrimStringT(BasicStringPiece<Str> input,
- BasicStringPiece<Str> trim_chars,
- TrimPositions positions,
- Str* output) {
- // Find the edges of leading/trailing whitespace as desired. Need to use
- // a StringPiece version of input to be able to call find* on it with the
- // StringPiece version of trim_chars (normally the trim_chars will be a
- // constant so avoid making a copy).
- const size_t last_char = input.length() - 1;
- const size_t first_good_char =
- (positions & TRIM_LEADING) ? input.find_first_not_of(trim_chars) : 0;
- const size_t last_good_char = (positions & TRIM_TRAILING)
- ? input.find_last_not_of(trim_chars)
- : last_char;
-
- // When the string was all trimmed, report that we stripped off characters
- // from whichever position the caller was interested in. For empty input, we
- // stripped no characters, but we still need to clear |output|.
- if (input.empty() || first_good_char == Str::npos ||
- last_good_char == Str::npos) {
- bool input_was_empty = input.empty(); // in case output == &input
- output->clear();
- return input_was_empty ? TRIM_NONE : positions;
- }
-
- // Trim.
- output->assign(input.data() + first_good_char,
- last_good_char - first_good_char + 1);
-
- // Return where we trimmed from.
- return static_cast<TrimPositions>(
- (first_good_char == 0 ? TRIM_NONE : TRIM_LEADING) |
- (last_good_char == last_char ? TRIM_NONE : TRIM_TRAILING));
+ return internal::ReplaceCharsT(input, remove_chars, StringPiece(), output);
}
bool TrimString(StringPiece16 input,
StringPiece16 trim_chars,
string16* output) {
- return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
+ return internal::TrimStringT(input, trim_chars, TRIM_ALL, output) !=
+ TRIM_NONE;
}
bool TrimString(StringPiece input,
StringPiece trim_chars,
std::string* output) {
- return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
-}
-
-template<typename Str>
-BasicStringPiece<Str> TrimStringPieceT(BasicStringPiece<Str> input,
- BasicStringPiece<Str> trim_chars,
- TrimPositions positions) {
- size_t begin = (positions & TRIM_LEADING) ?
- input.find_first_not_of(trim_chars) : 0;
- size_t end = (positions & TRIM_TRAILING) ?
- input.find_last_not_of(trim_chars) + 1 : input.size();
- return input.substr(begin, end - begin);
+ return internal::TrimStringT(input, trim_chars, TRIM_ALL, output) !=
+ TRIM_NONE;
}
StringPiece16 TrimString(StringPiece16 input,
StringPiece16 trim_chars,
TrimPositions positions) {
- return TrimStringPieceT(input, trim_chars, positions);
+ return internal::TrimStringPieceT(input, trim_chars, positions);
}
StringPiece TrimString(StringPiece input,
StringPiece trim_chars,
TrimPositions positions) {
- return TrimStringPieceT(input, trim_chars, positions);
+ return internal::TrimStringPieceT(input, trim_chars, positions);
}
void TruncateUTF8ToByteSize(const std::string& input,
@@ -357,74 +203,36 @@
TrimPositions TrimWhitespace(StringPiece16 input,
TrimPositions positions,
string16* output) {
- return TrimStringT(input, StringPiece16(kWhitespaceUTF16), positions, output);
+ return internal::TrimStringT(input, StringPiece16(kWhitespaceUTF16),
+ positions, output);
}
StringPiece16 TrimWhitespace(StringPiece16 input,
TrimPositions positions) {
- return TrimStringPieceT(input, StringPiece16(kWhitespaceUTF16), positions);
+ return internal::TrimStringPieceT(input, StringPiece16(kWhitespaceUTF16),
+ positions);
}
TrimPositions TrimWhitespaceASCII(StringPiece input,
TrimPositions positions,
std::string* output) {
- return TrimStringT(input, StringPiece(kWhitespaceASCII), positions, output);
+ return internal::TrimStringT(input, StringPiece(kWhitespaceASCII), positions,
+ output);
}
StringPiece TrimWhitespaceASCII(StringPiece input, TrimPositions positions) {
- return TrimStringPieceT(input, StringPiece(kWhitespaceASCII), positions);
+ return internal::TrimStringPieceT(input, StringPiece(kWhitespaceASCII),
+ positions);
}
-template<typename STR>
-STR CollapseWhitespaceT(const STR& text,
- bool trim_sequences_with_line_breaks) {
- STR result;
- result.resize(text.size());
-
- // Set flags to pretend we're already in a trimmed whitespace sequence, so we
- // will trim any leading whitespace.
- bool in_whitespace = true;
- bool already_trimmed = true;
-
- int chars_written = 0;
- for (typename STR::const_iterator i(text.begin()); i != text.end(); ++i) {
- if (IsUnicodeWhitespace(*i)) {
- if (!in_whitespace) {
- // Reduce all whitespace sequences to a single space.
- in_whitespace = true;
- result[chars_written++] = L' ';
- }
- if (trim_sequences_with_line_breaks && !already_trimmed &&
- ((*i == '\n') || (*i == '\r'))) {
- // Whitespace sequences containing CR or LF are eliminated entirely.
- already_trimmed = true;
- --chars_written;
- }
- } else {
- // Non-whitespace chracters are copied straight across.
- in_whitespace = false;
- already_trimmed = false;
- result[chars_written++] = *i;
- }
- }
-
- if (in_whitespace && !already_trimmed) {
- // Any trailing whitespace is eliminated.
- --chars_written;
- }
-
- result.resize(chars_written);
- return result;
-}
-
-string16 CollapseWhitespace(const string16& text,
+string16 CollapseWhitespace(StringPiece16 text,
bool trim_sequences_with_line_breaks) {
- return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
+ return internal::CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
}
-std::string CollapseWhitespaceASCII(const std::string& text,
+std::string CollapseWhitespaceASCII(StringPiece text,
bool trim_sequences_with_line_breaks) {
- return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
+ return internal::CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
}
bool ContainsOnlyChars(StringPiece input, StringPiece characters) {
@@ -435,198 +243,63 @@
return input.find_first_not_of(characters) == StringPiece16::npos;
}
-template <class Char>
-inline bool DoIsStringASCII(const Char* characters, size_t length) {
- if (!length)
- return true;
- constexpr MachineWord non_ascii_bit_mask = NonASCIIMask<Char>::value();
- MachineWord all_char_bits = 0;
- const Char* end = characters + length;
-
- // Prologue: align the input.
- while (!IsMachineWordAligned(characters) && characters < end)
- all_char_bits |= *characters++;
- if (all_char_bits & non_ascii_bit_mask)
- return false;
-
- // Compare the values of CPU word size.
- constexpr size_t chars_per_word = sizeof(MachineWord) / sizeof(Char);
- constexpr int batch_count = 16;
- while (characters <= end - batch_count * chars_per_word) {
- all_char_bits = 0;
- for (int i = 0; i < batch_count; ++i) {
- all_char_bits |= *(reinterpret_cast<const MachineWord*>(characters));
- characters += chars_per_word;
- }
- if (all_char_bits & non_ascii_bit_mask)
- return false;
- }
-
- // Process the remaining words.
- all_char_bits = 0;
- while (characters <= end - chars_per_word) {
- all_char_bits |= *(reinterpret_cast<const MachineWord*>(characters));
- characters += chars_per_word;
- }
-
- // Process the remaining bytes.
- while (characters < end)
- all_char_bits |= *characters++;
-
- return !(all_char_bits & non_ascii_bit_mask);
-}
bool IsStringASCII(StringPiece str) {
- return DoIsStringASCII(str.data(), str.length());
+ return internal::DoIsStringASCII(str.data(), str.length());
}
bool IsStringASCII(StringPiece16 str) {
- return DoIsStringASCII(str.data(), str.length());
+ return internal::DoIsStringASCII(str.data(), str.length());
}
#if defined(WCHAR_T_IS_UTF32)
bool IsStringASCII(WStringPiece str) {
- return DoIsStringASCII(str.data(), str.length());
+ return internal::DoIsStringASCII(str.data(), str.length());
}
#endif
-template <bool (*Validator)(uint32_t)>
-inline static bool DoIsStringUTF8(StringPiece str) {
- const char* src = str.data();
- int32_t src_len = static_cast<int32_t>(str.length());
- int32_t char_index = 0;
-
- while (char_index < src_len) {
- int32_t code_point;
- CBU8_NEXT(src, char_index, src_len, code_point);
- if (!Validator(code_point))
- return false;
- }
- return true;
-}
-
bool IsStringUTF8(StringPiece str) {
- return DoIsStringUTF8<IsValidCharacter>(str);
+ return internal::DoIsStringUTF8<IsValidCharacter>(str);
}
bool IsStringUTF8AllowingNoncharacters(StringPiece str) {
- return DoIsStringUTF8<IsValidCodepoint>(str);
-}
-
-// Implementation note: Normally this function will be called with a hardcoded
-// constant for the lowercase_ascii parameter. Constructing a StringPiece from
-// a C constant requires running strlen, so the result will be two passes
-// through the buffers, one to file the length of lowercase_ascii, and one to
-// compare each letter.
-//
-// This function could have taken a const char* to avoid this and only do one
-// pass through the string. But the strlen is faster than the case-insensitive
-// compares and lets us early-exit in the case that the strings are different
-// lengths (will often be the case for non-matches). So whether one approach or
-// the other will be faster depends on the case.
-//
-// The hardcoded strings are typically very short so it doesn't matter, and the
-// string piece gives additional flexibility for the caller (doesn't have to be
-// null terminated) so we choose the StringPiece route.
-template<typename Str>
-static inline bool DoLowerCaseEqualsASCII(BasicStringPiece<Str> str,
- StringPiece lowercase_ascii) {
- if (str.size() != lowercase_ascii.size())
- return false;
- for (size_t i = 0; i < str.size(); i++) {
- if (ToLowerASCII(str[i]) != lowercase_ascii[i])
- return false;
- }
- return true;
+ return internal::DoIsStringUTF8<IsValidCodepoint>(str);
}
bool LowerCaseEqualsASCII(StringPiece str, StringPiece lowercase_ascii) {
- return DoLowerCaseEqualsASCII<std::string>(str, lowercase_ascii);
+ return internal::DoLowerCaseEqualsASCII(str, lowercase_ascii);
}
bool LowerCaseEqualsASCII(StringPiece16 str, StringPiece lowercase_ascii) {
- return DoLowerCaseEqualsASCII<string16>(str, lowercase_ascii);
+ return internal::DoLowerCaseEqualsASCII(str, lowercase_ascii);
}
bool EqualsASCII(StringPiece16 str, StringPiece ascii) {
- if (str.length() != ascii.length())
- return false;
- return std::equal(ascii.begin(), ascii.end(), str.begin());
-}
-
-template<typename Str>
-bool StartsWithT(BasicStringPiece<Str> str,
- BasicStringPiece<Str> search_for,
- CompareCase case_sensitivity) {
- if (search_for.size() > str.size())
- return false;
-
- BasicStringPiece<Str> source = str.substr(0, search_for.size());
-
- switch (case_sensitivity) {
- case CompareCase::SENSITIVE:
- return source == search_for;
-
- case CompareCase::INSENSITIVE_ASCII:
- return std::equal(
- search_for.begin(), search_for.end(),
- source.begin(),
- CaseInsensitiveCompareASCII<typename Str::value_type>());
-
- default:
- GURL_NOTREACHED();
- return false;
- }
+ return std::equal(ascii.begin(), ascii.end(), str.begin(), str.end());
}
bool StartsWith(StringPiece str,
StringPiece search_for,
CompareCase case_sensitivity) {
- return StartsWithT<std::string>(str, search_for, case_sensitivity);
+ return internal::StartsWithT(str, search_for, case_sensitivity);
}
bool StartsWith(StringPiece16 str,
StringPiece16 search_for,
CompareCase case_sensitivity) {
- return StartsWithT<string16>(str, search_for, case_sensitivity);
-}
-
-template <typename Str>
-bool EndsWithT(BasicStringPiece<Str> str,
- BasicStringPiece<Str> search_for,
- CompareCase case_sensitivity) {
- if (search_for.size() > str.size())
- return false;
-
- BasicStringPiece<Str> source = str.substr(str.size() - search_for.size(),
- search_for.size());
-
- switch (case_sensitivity) {
- case CompareCase::SENSITIVE:
- return source == search_for;
-
- case CompareCase::INSENSITIVE_ASCII:
- return std::equal(
- source.begin(), source.end(),
- search_for.begin(),
- CaseInsensitiveCompareASCII<typename Str::value_type>());
-
- default:
- GURL_NOTREACHED();
- return false;
- }
+ return internal::StartsWithT(str, search_for, case_sensitivity);
}
bool EndsWith(StringPiece str,
StringPiece search_for,
CompareCase case_sensitivity) {
- return EndsWithT<std::string>(str, search_for, case_sensitivity);
+ return internal::EndsWithT(str, search_for, case_sensitivity);
}
bool EndsWith(StringPiece16 str,
StringPiece16 search_for,
CompareCase case_sensitivity) {
- return EndsWithT<string16>(str, search_for, case_sensitivity);
+ return internal::EndsWithT(str, search_for, case_sensitivity);
}
char HexDigitToInt(wchar_t c) {
@@ -680,384 +353,93 @@
return ASCIIToUTF16(buf);
}
-// A Matcher for DoReplaceMatchesAfterOffset() that matches substrings.
-template <class StringType>
-struct SubstringMatcher {
- BasicStringPiece<StringType> find_this;
-
- size_t Find(const StringType& input, size_t pos) {
- return input.find(find_this.data(), pos, find_this.length());
- }
- size_t MatchSize() { return find_this.length(); }
-};
-
-// A Matcher for DoReplaceMatchesAfterOffset() that matches single characters.
-template <class StringType>
-struct CharacterMatcher {
- BasicStringPiece<StringType> find_any_of_these;
-
- size_t Find(const StringType& input, size_t pos) {
- return input.find_first_of(find_any_of_these.data(), pos,
- find_any_of_these.length());
- }
- constexpr size_t MatchSize() { return 1; }
-};
-
-enum class ReplaceType { REPLACE_ALL, REPLACE_FIRST };
-
-// Runs in O(n) time in the length of |str|, and transforms the string without
-// reallocating when possible. Returns |true| if any matches were found.
-//
-// This is parameterized on a |Matcher| traits type, so that it can be the
-// implementation for both ReplaceChars() and ReplaceSubstringsAfterOffset().
-template <class StringType, class Matcher>
-bool DoReplaceMatchesAfterOffset(StringType* str,
- size_t initial_offset,
- Matcher matcher,
- BasicStringPiece<StringType> replace_with,
- ReplaceType replace_type) {
- using CharTraits = typename StringType::traits_type;
-
- const size_t find_length = matcher.MatchSize();
- if (!find_length)
- return false;
-
- // If the find string doesn't appear, there's nothing to do.
- size_t first_match = matcher.Find(*str, initial_offset);
- if (first_match == StringType::npos)
- return false;
-
- // If we're only replacing one instance, there's no need to do anything
- // complicated.
- const size_t replace_length = replace_with.length();
- if (replace_type == ReplaceType::REPLACE_FIRST) {
- str->replace(first_match, find_length, replace_with.data(), replace_length);
- return true;
- }
-
- // If the find and replace strings are the same length, we can simply use
- // replace() on each instance, and finish the entire operation in O(n) time.
- if (find_length == replace_length) {
- auto* buffer = &((*str)[0]);
- for (size_t offset = first_match; offset != StringType::npos;
- offset = matcher.Find(*str, offset + replace_length)) {
- CharTraits::copy(buffer + offset, replace_with.data(), replace_length);
- }
- return true;
- }
-
- // Since the find and replace strings aren't the same length, a loop like the
- // one above would be O(n^2) in the worst case, as replace() will shift the
- // entire remaining string each time. We need to be more clever to keep things
- // O(n).
- //
- // When the string is being shortened, it's possible to just shift the matches
- // down in one pass while finding, and truncate the length at the end of the
- // search.
- //
- // If the string is being lengthened, more work is required. The strategy used
- // here is to make two find() passes through the string. The first pass counts
- // the number of matches to determine the new size. The second pass will
- // either construct the new string into a new buffer (if the existing buffer
- // lacked capacity), or else -- if there is room -- create a region of scratch
- // space after |first_match| by shifting the tail of the string to a higher
- // index, and doing in-place moves from the tail to lower indices thereafter.
- size_t str_length = str->length();
- size_t expansion = 0;
- if (replace_length > find_length) {
- // This operation lengthens the string; determine the new length by counting
- // matches.
- const size_t expansion_per_match = (replace_length - find_length);
- size_t num_matches = 0;
- for (size_t match = first_match; match != StringType::npos;
- match = matcher.Find(*str, match + find_length)) {
- expansion += expansion_per_match;
- ++num_matches;
- }
- const size_t final_length = str_length + expansion;
-
- if (str->capacity() < final_length) {
- // If we'd have to allocate a new buffer to grow the string, build the
- // result directly into the new allocation via append().
- StringType src(str->get_allocator());
- str->swap(src);
- str->reserve(final_length);
-
- size_t pos = 0;
- for (size_t match = first_match;; match = matcher.Find(src, pos)) {
- str->append(src, pos, match - pos);
- str->append(replace_with.data(), replace_length);
- pos = match + find_length;
-
- // A mid-loop test/break enables skipping the final Find() call; the
- // number of matches is known, so don't search past the last one.
- if (!--num_matches)
- break;
- }
-
- // Handle substring after the final match.
- str->append(src, pos, str_length - pos);
- return true;
- }
-
- // Prepare for the copy/move loop below -- expand the string to its final
- // size by shifting the data after the first match to the end of the resized
- // string.
- size_t shift_src = first_match + find_length;
- size_t shift_dst = shift_src + expansion;
-
- // Big |expansion| factors (relative to |str_length|) require padding up to
- // |shift_dst|.
- if (shift_dst > str_length)
- str->resize(shift_dst);
-
- str->replace(shift_dst, str_length - shift_src, *str, shift_src,
- str_length - shift_src);
- str_length = final_length;
- }
-
- // We can alternate replacement and move operations. This won't overwrite the
- // unsearched region of the string so long as |write_offset| <= |read_offset|;
- // that condition is always satisfied because:
- //
- // (a) If the string is being shortened, |expansion| is zero and
- // |write_offset| grows slower than |read_offset|.
- //
- // (b) If the string is being lengthened, |write_offset| grows faster than
- // |read_offset|, but |expansion| is big enough so that |write_offset|
- // will only catch up to |read_offset| at the point of the last match.
- auto* buffer = &((*str)[0]);
- size_t write_offset = first_match;
- size_t read_offset = first_match + expansion;
- do {
- if (replace_length) {
- CharTraits::copy(buffer + write_offset, replace_with.data(),
- replace_length);
- write_offset += replace_length;
- }
- read_offset += find_length;
-
- // min() clamps StringType::npos (the largest unsigned value) to str_length.
- size_t match = std::min(matcher.Find(*str, read_offset), str_length);
-
- size_t length = match - read_offset;
- if (length) {
- CharTraits::move(buffer + write_offset, buffer + read_offset, length);
- write_offset += length;
- read_offset += length;
- }
- } while (read_offset < str_length);
-
- // If we're shortening the string, truncate it now.
- str->resize(write_offset);
- return true;
-}
-
-template <class StringType>
-bool ReplaceCharsT(const StringType& input,
- BasicStringPiece<StringType> find_any_of_these,
- BasicStringPiece<StringType> replace_with,
- StringType* output) {
- // Commonly, this is called with output and input being the same string; in
- // that case, this assignment is inexpensive.
- *output = input;
-
- return DoReplaceMatchesAfterOffset(
- output, 0, CharacterMatcher<StringType>{find_any_of_these}, replace_with,
- ReplaceType::REPLACE_ALL);
-}
-
void ReplaceFirstSubstringAfterOffset(string16* str,
size_t start_offset,
StringPiece16 find_this,
StringPiece16 replace_with) {
- DoReplaceMatchesAfterOffset(str, start_offset,
- SubstringMatcher<string16>{find_this},
- replace_with, ReplaceType::REPLACE_FIRST);
+ internal::DoReplaceMatchesAfterOffset(
+ str, start_offset, internal::SubstringMatcher<string16>{find_this},
+ replace_with, internal::ReplaceType::REPLACE_FIRST);
}
void ReplaceFirstSubstringAfterOffset(std::string* str,
size_t start_offset,
StringPiece find_this,
StringPiece replace_with) {
- DoReplaceMatchesAfterOffset(str, start_offset,
- SubstringMatcher<std::string>{find_this},
- replace_with, ReplaceType::REPLACE_FIRST);
+ internal::DoReplaceMatchesAfterOffset(
+ str, start_offset, internal::SubstringMatcher<std::string>{find_this},
+ replace_with, internal::ReplaceType::REPLACE_FIRST);
}
void ReplaceSubstringsAfterOffset(string16* str,
size_t start_offset,
StringPiece16 find_this,
StringPiece16 replace_with) {
- DoReplaceMatchesAfterOffset(str, start_offset,
- SubstringMatcher<string16>{find_this},
- replace_with, ReplaceType::REPLACE_ALL);
+ internal::DoReplaceMatchesAfterOffset(
+ str, start_offset, internal::SubstringMatcher<string16>{find_this},
+ replace_with, internal::ReplaceType::REPLACE_ALL);
}
void ReplaceSubstringsAfterOffset(std::string* str,
size_t start_offset,
StringPiece find_this,
StringPiece replace_with) {
- DoReplaceMatchesAfterOffset(str, start_offset,
- SubstringMatcher<std::string>{find_this},
- replace_with, ReplaceType::REPLACE_ALL);
-}
-
-template <class string_type>
-inline typename string_type::value_type* WriteIntoT(string_type* str,
- size_t length_with_null) {
- GURL_DCHECK_GE(length_with_null, 1u);
- str->reserve(length_with_null);
- str->resize(length_with_null - 1);
- return &((*str)[0]);
+ internal::DoReplaceMatchesAfterOffset(
+ str, start_offset, internal::SubstringMatcher<std::string>{find_this},
+ replace_with, internal::ReplaceType::REPLACE_ALL);
}
char* WriteInto(std::string* str, size_t length_with_null) {
- return WriteIntoT(str, length_with_null);
+ return internal::WriteIntoT(str, length_with_null);
}
char16* WriteInto(string16* str, size_t length_with_null) {
- return WriteIntoT(str, length_with_null);
+ return internal::WriteIntoT(str, length_with_null);
}
-// Generic version for all JoinString overloads. |list_type| must be a sequence
-// (std::vector or std::initializer_list) of strings/StringPieces (std::string,
-// string16, StringPiece or StringPiece16). |string_type| is either std::string
-// or string16.
-template <typename list_type, typename string_type>
-static string_type JoinStringT(const list_type& parts,
- BasicStringPiece<string_type> sep) {
- if (gurl_base::empty(parts))
- return string_type();
-
- // Pre-allocate the eventual size of the string. Start with the size of all of
- // the separators (note that this *assumes* parts.size() > 0).
- size_t total_size = (parts.size() - 1) * sep.size();
- for (const auto& part : parts)
- total_size += part.size();
- string_type result;
- result.reserve(total_size);
-
- auto iter = parts.begin();
- GURL_DCHECK(iter != parts.end());
- result.append(iter->data(), iter->size());
- ++iter;
-
- for (; iter != parts.end(); ++iter) {
- result.append(sep.data(), sep.size());
- result.append(iter->data(), iter->size());
- }
-
- // Sanity-check that we pre-allocated correctly.
- GURL_DCHECK_EQ(total_size, result.size());
-
- return result;
+std::string JoinString(span<const std::string> parts, StringPiece separator) {
+ return internal::JoinStringT(parts, separator);
}
-std::string JoinString(const std::vector<std::string>& parts,
- StringPiece separator) {
- return JoinStringT(parts, separator);
+string16 JoinString(span<const string16> parts, StringPiece16 separator) {
+ return internal::JoinStringT(parts, separator);
}
-string16 JoinString(const std::vector<string16>& parts,
- StringPiece16 separator) {
- return JoinStringT(parts, separator);
+std::string JoinString(span<const StringPiece> parts, StringPiece separator) {
+ return internal::JoinStringT(parts, separator);
}
-std::string JoinString(const std::vector<StringPiece>& parts,
- StringPiece separator) {
- return JoinStringT(parts, separator);
-}
-
-string16 JoinString(const std::vector<StringPiece16>& parts,
- StringPiece16 separator) {
- return JoinStringT(parts, separator);
+string16 JoinString(span<const StringPiece16> parts, StringPiece16 separator) {
+ return internal::JoinStringT(parts, separator);
}
std::string JoinString(std::initializer_list<StringPiece> parts,
StringPiece separator) {
- return JoinStringT(parts, separator);
+ return internal::JoinStringT(parts, separator);
}
string16 JoinString(std::initializer_list<StringPiece16> parts,
StringPiece16 separator) {
- return JoinStringT(parts, separator);
+ return internal::JoinStringT(parts, separator);
}
-template<class FormatStringType, class OutStringType>
-OutStringType DoReplaceStringPlaceholders(
- const FormatStringType& format_string,
- const std::vector<OutStringType>& subst,
- std::vector<size_t>* offsets) {
- size_t substitutions = subst.size();
- GURL_DCHECK_LT(substitutions, 10U);
-
- size_t sub_length = 0;
- for (const auto& cur : subst)
- sub_length += cur.length();
-
- OutStringType formatted;
- formatted.reserve(format_string.length() + sub_length);
-
- std::vector<ReplacementOffset> r_offsets;
- for (auto i = format_string.begin(); i != format_string.end(); ++i) {
- if ('$' == *i) {
- if (i + 1 != format_string.end()) {
- ++i;
- if ('$' == *i) {
- while (i != format_string.end() && '$' == *i) {
- formatted.push_back('$');
- ++i;
- }
- --i;
- } else {
- if (*i < '1' || *i > '9') {
- GURL_DLOG(ERROR) << "Invalid placeholder: $" << *i;
- continue;
- }
- uintptr_t index = *i - '1';
- if (offsets) {
- ReplacementOffset r_offset(index,
- static_cast<int>(formatted.size()));
- r_offsets.insert(
- std::upper_bound(r_offsets.begin(), r_offsets.end(), r_offset,
- &CompareParameter),
- r_offset);
- }
- if (index < substitutions)
- formatted.append(subst.at(index));
- }
- }
- } else {
- formatted.push_back(*i);
- }
- }
- if (offsets) {
- for (const auto& cur : r_offsets)
- offsets->push_back(cur.offset);
- }
- return formatted;
-}
-
-string16 ReplaceStringPlaceholders(const string16& format_string,
+string16 ReplaceStringPlaceholders(StringPiece16 format_string,
const std::vector<string16>& subst,
std::vector<size_t>* offsets) {
- return DoReplaceStringPlaceholders(format_string, subst, offsets);
+ return internal::DoReplaceStringPlaceholders(format_string, subst, offsets);
}
std::string ReplaceStringPlaceholders(StringPiece format_string,
const std::vector<std::string>& subst,
std::vector<size_t>* offsets) {
- return DoReplaceStringPlaceholders(format_string, subst, offsets);
+ return internal::DoReplaceStringPlaceholders(format_string, subst, offsets);
}
string16 ReplaceStringPlaceholders(const string16& format_string,
const string16& a,
size_t* offset) {
std::vector<size_t> offsets;
- std::vector<string16> subst;
- subst.push_back(a);
- string16 result = ReplaceStringPlaceholders(format_string, subst, &offsets);
+ string16 result = ReplaceStringPlaceholders(format_string, {a}, &offsets);
GURL_DCHECK_EQ(1U, offsets.size());
if (offset)
@@ -1065,65 +447,11 @@
return result;
}
-#if defined(OS_WIN) && defined(BASE_STRING16_IS_STD_U16STRING)
-
-TrimPositions TrimWhitespace(WStringPiece input,
- TrimPositions positions,
- std::wstring* output) {
- return TrimStringT(input, WStringPiece(kWhitespaceWide), positions, output);
-}
-
-WStringPiece TrimWhitespace(WStringPiece input, TrimPositions positions) {
- return TrimStringPieceT(input, WStringPiece(kWhitespaceWide), positions);
-}
-
-bool TrimString(WStringPiece input,
- WStringPiece trim_chars,
- std::wstring* output) {
- return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
-}
-
-WStringPiece TrimString(WStringPiece input,
- WStringPiece trim_chars,
- TrimPositions positions) {
- return TrimStringPieceT(input, trim_chars, positions);
-}
-
-wchar_t* WriteInto(std::wstring* str, size_t length_with_null) {
- return WriteIntoT(str, length_with_null);
-}
-
-#endif
-
-// The following code is compatible with the OpenBSD lcpy interface. See:
-// http://www.gratisoft.us/todd/papers/strlcpy.html
-// ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/{wcs,str}lcpy.c
-
-namespace {
-
-template <typename CHAR>
-size_t lcpyT(CHAR* dst, const CHAR* src, size_t dst_size) {
- for (size_t i = 0; i < dst_size; ++i) {
- if ((dst[i] = src[i]) == 0) // We hit and copied the terminating NULL.
- return i;
- }
-
- // We were left off at dst_size. We over copied 1 byte. Null terminate.
- if (dst_size != 0)
- dst[dst_size - 1] = 0;
-
- // Count the rest of the |src|, and return it's length in characters.
- while (src[dst_size]) ++dst_size;
- return dst_size;
-}
-
-} // namespace
-
size_t strlcpy(char* dst, const char* src, size_t dst_size) {
- return lcpyT<char>(dst, src, dst_size);
+ return internal::lcpyT(dst, src, dst_size);
}
size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
- return lcpyT<wchar_t>(dst, src, dst_size);
+ return internal::lcpyT(dst, src, dst_size);
}
} // namespace base
diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index ed3118d..1445283 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -14,10 +14,12 @@
#include <initializer_list>
#include <string>
+#include <type_traits>
#include <vector>
#include "polyfills/base/base_export.h"
#include "base/compiler_specific.h"
+#include "base/containers/span.h"
#include "base/stl_util.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h" // For implicit conversions.
@@ -84,19 +86,17 @@
// ASCII-specific tolower. The standard library's tolower is locale sensitive,
// so we don't want to use it here.
-inline char ToLowerASCII(char c) {
- return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
-}
-inline char16 ToLowerASCII(char16 c) {
+template <typename CharT,
+ typename = std::enable_if_t<std::is_integral<CharT>::value>>
+CharT ToLowerASCII(CharT c) {
return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
}
// ASCII-specific toupper. The standard library's toupper is locale sensitive,
// so we don't want to use it here.
-inline char ToUpperASCII(char c) {
- return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
-}
-inline char16 ToUpperASCII(char16 c) {
+template <typename CharT,
+ typename = std::enable_if_t<std::is_integral<CharT>::value>>
+CharT ToUpperASCII(CharT c) {
return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
}
@@ -170,10 +170,10 @@
// Removes characters in |remove_chars| from anywhere in |input|. Returns true
// if any characters were removed. |remove_chars| must be null-terminated.
// NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool RemoveChars(const string16& input,
+BASE_EXPORT bool RemoveChars(StringPiece16 input,
StringPiece16 remove_chars,
string16* output);
-BASE_EXPORT bool RemoveChars(const std::string& input,
+BASE_EXPORT bool RemoveChars(StringPiece input,
StringPiece remove_chars,
std::string* output);
@@ -182,11 +182,11 @@
// the |replace_with| string. Returns true if any characters were replaced.
// |replace_chars| must be null-terminated.
// NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool ReplaceChars(const string16& input,
+BASE_EXPORT bool ReplaceChars(StringPiece16 input,
StringPiece16 replace_chars,
StringPiece16 replace_with,
string16* output);
-BASE_EXPORT bool ReplaceChars(const std::string& input,
+BASE_EXPORT bool ReplaceChars(StringPiece input,
StringPiece replace_chars,
StringPiece replace_with,
std::string* output);
@@ -226,69 +226,6 @@
const size_t byte_size,
std::string* output);
-#if defined(WCHAR_T_IS_UTF16)
-// Utility functions to access the underlying string buffer as a wide char
-// pointer.
-//
-// Note: These functions violate strict aliasing when char16 and wchar_t are
-// unrelated types. We thus pass -fno-strict-aliasing to the compiler on
-// non-Windows platforms [1], and rely on it being off in Clang's CL mode [2].
-//
-// [1] https://crrev.com/b9a0976622/build/config/compiler/BUILD.gn#244
-// [2]
-// https://github.com/llvm/llvm-project/blob/1e28a66/clang/lib/Driver/ToolChains/Clang.cpp#L3949
-inline wchar_t* as_writable_wcstr(char16* str) {
- return reinterpret_cast<wchar_t*>(str);
-}
-
-inline wchar_t* as_writable_wcstr(string16& str) {
- return reinterpret_cast<wchar_t*>(data(str));
-}
-
-inline const wchar_t* as_wcstr(const char16* str) {
- return reinterpret_cast<const wchar_t*>(str);
-}
-
-inline const wchar_t* as_wcstr(StringPiece16 str) {
- return reinterpret_cast<const wchar_t*>(str.data());
-}
-
-// Utility functions to access the underlying string buffer as a char16 pointer.
-inline char16* as_writable_u16cstr(wchar_t* str) {
- return reinterpret_cast<char16*>(str);
-}
-
-inline char16* as_writable_u16cstr(std::wstring& str) {
- return reinterpret_cast<char16*>(data(str));
-}
-
-inline const char16* as_u16cstr(const wchar_t* str) {
- return reinterpret_cast<const char16*>(str);
-}
-
-inline const char16* as_u16cstr(WStringPiece str) {
- return reinterpret_cast<const char16*>(str.data());
-}
-
-// Utility functions to convert between gurl_base::WStringPiece and
-// gurl_base::StringPiece16.
-inline WStringPiece AsWStringPiece(StringPiece16 str) {
- return WStringPiece(as_wcstr(str.data()), str.size());
-}
-
-inline StringPiece16 AsStringPiece16(WStringPiece str) {
- return StringPiece16(as_u16cstr(str.data()), str.size());
-}
-
-inline std::wstring AsWString(StringPiece16 str) {
- return std::wstring(as_wcstr(str.data()), str.size());
-}
-
-inline string16 AsString16(WStringPiece str) {
- return string16(as_u16cstr(str.data()), str.size());
-}
-#endif // defined(WCHAR_T_IS_UTF16)
-
// Trims any whitespace from either end of the input string.
//
// The StringPiece versions return a substring referencing the input buffer.
@@ -315,11 +252,10 @@
// (2) If |trim_sequences_with_line_breaks| is true, any other whitespace
// sequences containing a CR or LF are trimmed.
// (3) All other whitespace sequences are converted to single spaces.
-BASE_EXPORT string16 CollapseWhitespace(
- const string16& text,
- bool trim_sequences_with_line_breaks);
+BASE_EXPORT string16 CollapseWhitespace(StringPiece16 text,
+ bool trim_sequences_with_line_breaks);
BASE_EXPORT std::string CollapseWhitespaceASCII(
- const std::string& text,
+ StringPiece text,
bool trim_sequences_with_line_breaks);
// Returns true if |input| is empty or contains only characters found in
@@ -347,6 +283,7 @@
// does not leave early if it is not the case.
BASE_EXPORT bool IsStringASCII(StringPiece str);
BASE_EXPORT bool IsStringASCII(StringPiece16 str);
+
#if defined(WCHAR_T_IS_UTF32)
BASE_EXPORT bool IsStringASCII(WStringPiece str);
#endif
@@ -488,8 +425,8 @@
BASE_EXPORT char* WriteInto(std::string* str, size_t length_with_null);
BASE_EXPORT char16* WriteInto(string16* str, size_t length_with_null);
-// Joins a vector or list of strings into a single string, inserting |separator|
-// (which may be empty) in between all elements.
+// Joins a list of strings into a single string, inserting |separator| (which
+// may be empty) in between all elements.
//
// Note this is inverse of SplitString()/SplitStringPiece() defined in
// string_split.h.
@@ -501,13 +438,13 @@
// copies of those strings are created until the final join operation.
//
// Use StrCat (in base/strings/strcat.h) if you don't need a separator.
-BASE_EXPORT std::string JoinString(const std::vector<std::string>& parts,
+BASE_EXPORT std::string JoinString(span<const std::string> parts,
StringPiece separator);
-BASE_EXPORT string16 JoinString(const std::vector<string16>& parts,
+BASE_EXPORT string16 JoinString(span<const string16> parts,
StringPiece16 separator);
-BASE_EXPORT std::string JoinString(const std::vector<StringPiece>& parts,
+BASE_EXPORT std::string JoinString(span<const StringPiece> parts,
StringPiece separator);
-BASE_EXPORT string16 JoinString(const std::vector<StringPiece16>& parts,
+BASE_EXPORT string16 JoinString(span<const StringPiece16> parts,
StringPiece16 separator);
// Explicit initializer_list overloads are required to break ambiguity when used
// with a literal initializer list (otherwise the compiler would not be able to
@@ -521,10 +458,10 @@
// Additionally, any number of consecutive '$' characters is replaced by that
// number less one. Eg $$->$, $$$->$$, etc. The offsets parameter here can be
// NULL. This only allows you to use up to nine replacements.
-BASE_EXPORT string16 ReplaceStringPlaceholders(
- const string16& format_string,
- const std::vector<string16>& subst,
- std::vector<size_t>* offsets);
+BASE_EXPORT string16
+ReplaceStringPlaceholders(StringPiece16 format_string,
+ const std::vector<string16>& subst,
+ std::vector<size_t>* offsets);
BASE_EXPORT std::string ReplaceStringPlaceholders(
StringPiece format_string,
@@ -536,25 +473,6 @@
const string16& a,
size_t* offset);
-#if defined(OS_WIN) && defined(BASE_STRING16_IS_STD_U16STRING)
-BASE_EXPORT TrimPositions TrimWhitespace(WStringPiece input,
- TrimPositions positions,
- std::wstring* output);
-
-BASE_EXPORT WStringPiece TrimWhitespace(WStringPiece input,
- TrimPositions positions);
-
-BASE_EXPORT bool TrimString(WStringPiece input,
- WStringPiece trim_chars,
- std::wstring* output);
-
-BASE_EXPORT WStringPiece TrimString(WStringPiece input,
- WStringPiece trim_chars,
- TrimPositions positions);
-
-BASE_EXPORT wchar_t* WriteInto(std::wstring* str, size_t length_with_null);
-#endif
-
} // namespace base
#if defined(OS_WIN)
diff --git a/base/strings/string_util_internal.h b/base/strings/string_util_internal.h
new file mode 100644
index 0000000..ace0665
--- /dev/null
+++ b/base/strings/string_util_internal.h
@@ -0,0 +1,625 @@
+// Copyright 2020 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_STRINGS_STRING_UTIL_INTERNAL_H_
+#define BASE_STRINGS_STRING_UTIL_INTERNAL_H_
+
+#include "polyfills/base/logging.h"
+#include "polyfills/base/notreached.h"
+#include "base/strings/string_piece.h"
+#include "base/third_party/icu/icu_utf.h"
+
+namespace gurl_base {
+
+namespace internal {
+
+// Used by ReplaceStringPlaceholders to track the position in the string of
+// replaced parameters.
+struct ReplacementOffset {
+ ReplacementOffset(uintptr_t parameter, size_t offset)
+ : parameter(parameter), offset(offset) {}
+
+ // Index of the parameter.
+ uintptr_t parameter;
+
+ // Starting position in the string.
+ size_t offset;
+};
+
+static bool CompareParameter(const ReplacementOffset& elem1,
+ const ReplacementOffset& elem2) {
+ return elem1.parameter < elem2.parameter;
+}
+
+// Assuming that a pointer is the size of a "machine word", then
+// uintptr_t is an integer type that is also a machine word.
+using MachineWord = uintptr_t;
+
+inline bool IsMachineWordAligned(const void* pointer) {
+ return !(reinterpret_cast<MachineWord>(pointer) & (sizeof(MachineWord) - 1));
+}
+
+template <typename StringType>
+StringType ToLowerASCIIImpl(BasicStringPiece<StringType> str) {
+ StringType ret;
+ ret.reserve(str.size());
+ for (size_t i = 0; i < str.size(); i++)
+ ret.push_back(ToLowerASCII(str[i]));
+ return ret;
+}
+
+template <typename StringType>
+StringType ToUpperASCIIImpl(BasicStringPiece<StringType> str) {
+ StringType ret;
+ ret.reserve(str.size());
+ for (size_t i = 0; i < str.size(); i++)
+ ret.push_back(ToUpperASCII(str[i]));
+ return ret;
+}
+
+template <class StringType>
+int CompareCaseInsensitiveASCIIT(BasicStringPiece<StringType> a,
+ BasicStringPiece<StringType> b) {
+ // Find the first characters that aren't equal and compare them. If the end
+ // of one of the strings is found before a nonequal character, the lengths
+ // of the strings are compared.
+ size_t i = 0;
+ while (i < a.length() && i < b.length()) {
+ typename StringType::value_type lower_a = ToLowerASCII(a[i]);
+ typename StringType::value_type lower_b = ToLowerASCII(b[i]);
+ if (lower_a < lower_b)
+ return -1;
+ if (lower_a > lower_b)
+ return 1;
+ i++;
+ }
+
+ // End of one string hit before finding a different character. Expect the
+ // common case to be "strings equal" at this point so check that first.
+ if (a.length() == b.length())
+ return 0;
+
+ if (a.length() < b.length())
+ return -1;
+ return 1;
+}
+
+template <typename Str>
+TrimPositions TrimStringT(BasicStringPiece<Str> input,
+ BasicStringPiece<Str> trim_chars,
+ TrimPositions positions,
+ Str* output) {
+ // Find the edges of leading/trailing whitespace as desired. Need to use
+ // a StringPiece version of input to be able to call find* on it with the
+ // StringPiece version of trim_chars (normally the trim_chars will be a
+ // constant so avoid making a copy).
+ const size_t last_char = input.length() - 1;
+ const size_t first_good_char =
+ (positions & TRIM_LEADING) ? input.find_first_not_of(trim_chars) : 0;
+ const size_t last_good_char = (positions & TRIM_TRAILING)
+ ? input.find_last_not_of(trim_chars)
+ : last_char;
+
+ // When the string was all trimmed, report that we stripped off characters
+ // from whichever position the caller was interested in. For empty input, we
+ // stripped no characters, but we still need to clear |output|.
+ if (input.empty() || first_good_char == Str::npos ||
+ last_good_char == Str::npos) {
+ bool input_was_empty = input.empty(); // in case output == &input
+ output->clear();
+ return input_was_empty ? TRIM_NONE : positions;
+ }
+
+ // Trim.
+ output->assign(input.data() + first_good_char,
+ last_good_char - first_good_char + 1);
+
+ // Return where we trimmed from.
+ return static_cast<TrimPositions>(
+ (first_good_char == 0 ? TRIM_NONE : TRIM_LEADING) |
+ (last_good_char == last_char ? TRIM_NONE : TRIM_TRAILING));
+}
+
+template <typename Str>
+BasicStringPiece<Str> TrimStringPieceT(BasicStringPiece<Str> input,
+ BasicStringPiece<Str> trim_chars,
+ TrimPositions positions) {
+ size_t begin =
+ (positions & TRIM_LEADING) ? input.find_first_not_of(trim_chars) : 0;
+ size_t end = (positions & TRIM_TRAILING)
+ ? input.find_last_not_of(trim_chars) + 1
+ : input.size();
+ return input.substr(begin, end - begin);
+}
+
+template <typename STR>
+STR CollapseWhitespaceT(BasicStringPiece<STR> text,
+ bool trim_sequences_with_line_breaks) {
+ STR result;
+ result.resize(text.size());
+
+ // Set flags to pretend we're already in a trimmed whitespace sequence, so we
+ // will trim any leading whitespace.
+ bool in_whitespace = true;
+ bool already_trimmed = true;
+
+ int chars_written = 0;
+ for (auto c : text) {
+ if (IsUnicodeWhitespace(c)) {
+ if (!in_whitespace) {
+ // Reduce all whitespace sequences to a single space.
+ in_whitespace = true;
+ result[chars_written++] = L' ';
+ }
+ if (trim_sequences_with_line_breaks && !already_trimmed &&
+ ((c == '\n') || (c == '\r'))) {
+ // Whitespace sequences containing CR or LF are eliminated entirely.
+ already_trimmed = true;
+ --chars_written;
+ }
+ } else {
+ // Non-whitespace characters are copied straight across.
+ in_whitespace = false;
+ already_trimmed = false;
+ result[chars_written++] = c;
+ }
+ }
+
+ if (in_whitespace && !already_trimmed) {
+ // Any trailing whitespace is eliminated.
+ --chars_written;
+ }
+
+ result.resize(chars_written);
+ return result;
+}
+
+template <class Char>
+bool DoIsStringASCII(const Char* characters, size_t length) {
+ // Bitmasks to detect non ASCII characters for character sizes of 8, 16 and 32
+ // bits.
+ constexpr MachineWord NonASCIIMasks[] = {
+ 0, MachineWord(0x8080808080808080ULL), MachineWord(0xFF80FF80FF80FF80ULL),
+ 0, MachineWord(0xFFFFFF80FFFFFF80ULL),
+ };
+
+ if (!length)
+ return true;
+ constexpr MachineWord non_ascii_bit_mask = NonASCIIMasks[sizeof(Char)];
+ static_assert(non_ascii_bit_mask, "Error: Invalid Mask");
+ MachineWord all_char_bits = 0;
+ const Char* end = characters + length;
+
+ // Prologue: align the input.
+ while (!IsMachineWordAligned(characters) && characters < end)
+ all_char_bits |= *characters++;
+ if (all_char_bits & non_ascii_bit_mask)
+ return false;
+
+ // Compare the values of CPU word size.
+ constexpr size_t chars_per_word = sizeof(MachineWord) / sizeof(Char);
+ constexpr int batch_count = 16;
+ while (characters <= end - batch_count * chars_per_word) {
+ all_char_bits = 0;
+ for (int i = 0; i < batch_count; ++i) {
+ all_char_bits |= *(reinterpret_cast<const MachineWord*>(characters));
+ characters += chars_per_word;
+ }
+ if (all_char_bits & non_ascii_bit_mask)
+ return false;
+ }
+
+ // Process the remaining words.
+ all_char_bits = 0;
+ while (characters <= end - chars_per_word) {
+ all_char_bits |= *(reinterpret_cast<const MachineWord*>(characters));
+ characters += chars_per_word;
+ }
+
+ // Process the remaining bytes.
+ while (characters < end)
+ all_char_bits |= *characters++;
+
+ return !(all_char_bits & non_ascii_bit_mask);
+}
+
+template <bool (*Validator)(uint32_t)>
+inline static bool DoIsStringUTF8(StringPiece str) {
+ const char* src = str.data();
+ int32_t src_len = static_cast<int32_t>(str.length());
+ int32_t char_index = 0;
+
+ while (char_index < src_len) {
+ int32_t code_point;
+ CBU8_NEXT(src, char_index, src_len, code_point);
+ if (!Validator(code_point))
+ return false;
+ }
+ return true;
+}
+
+// Implementation note: Normally this function will be called with a hardcoded
+// constant for the lowercase_ascii parameter. Constructing a StringPiece from
+// a C constant requires running strlen, so the result will be two passes
+// through the buffers, one to file the length of lowercase_ascii, and one to
+// compare each letter.
+//
+// This function could have taken a const char* to avoid this and only do one
+// pass through the string. But the strlen is faster than the case-insensitive
+// compares and lets us early-exit in the case that the strings are different
+// lengths (will often be the case for non-matches). So whether one approach or
+// the other will be faster depends on the case.
+//
+// The hardcoded strings are typically very short so it doesn't matter, and the
+// string piece gives additional flexibility for the caller (doesn't have to be
+// null terminated) so we choose the StringPiece route.
+template <typename Str>
+static inline bool DoLowerCaseEqualsASCII(BasicStringPiece<Str> str,
+ StringPiece lowercase_ascii) {
+ return std::equal(
+ str.begin(), str.end(), lowercase_ascii.begin(), lowercase_ascii.end(),
+ [](auto lhs, auto rhs) { return ToLowerASCII(lhs) == rhs; });
+}
+
+template <typename Str>
+bool StartsWithT(BasicStringPiece<Str> str,
+ BasicStringPiece<Str> search_for,
+ CompareCase case_sensitivity) {
+ if (search_for.size() > str.size())
+ return false;
+
+ BasicStringPiece<Str> source = str.substr(0, search_for.size());
+
+ switch (case_sensitivity) {
+ case CompareCase::SENSITIVE:
+ return source == search_for;
+
+ case CompareCase::INSENSITIVE_ASCII:
+ return std::equal(
+ search_for.begin(), search_for.end(), source.begin(),
+ CaseInsensitiveCompareASCII<typename Str::value_type>());
+
+ default:
+ GURL_NOTREACHED();
+ return false;
+ }
+}
+
+template <typename Str>
+bool EndsWithT(BasicStringPiece<Str> str,
+ BasicStringPiece<Str> search_for,
+ CompareCase case_sensitivity) {
+ if (search_for.size() > str.size())
+ return false;
+
+ BasicStringPiece<Str> source =
+ str.substr(str.size() - search_for.size(), search_for.size());
+
+ switch (case_sensitivity) {
+ case CompareCase::SENSITIVE:
+ return source == search_for;
+
+ case CompareCase::INSENSITIVE_ASCII:
+ return std::equal(
+ source.begin(), source.end(), search_for.begin(),
+ CaseInsensitiveCompareASCII<typename Str::value_type>());
+
+ default:
+ GURL_NOTREACHED();
+ return false;
+ }
+}
+
+// A Matcher for DoReplaceMatchesAfterOffset() that matches substrings.
+template <class StringType>
+struct SubstringMatcher {
+ BasicStringPiece<StringType> find_this;
+
+ size_t Find(const StringType& input, size_t pos) {
+ return input.find(find_this.data(), pos, find_this.length());
+ }
+ size_t MatchSize() { return find_this.length(); }
+};
+
+// A Matcher for DoReplaceMatchesAfterOffset() that matches single characters.
+template <class StringType>
+struct CharacterMatcher {
+ BasicStringPiece<StringType> find_any_of_these;
+
+ size_t Find(const StringType& input, size_t pos) {
+ return input.find_first_of(find_any_of_these.data(), pos,
+ find_any_of_these.length());
+ }
+ constexpr size_t MatchSize() { return 1; }
+};
+
+enum class ReplaceType { REPLACE_ALL, REPLACE_FIRST };
+
+// Runs in O(n) time in the length of |str|, and transforms the string without
+// reallocating when possible. Returns |true| if any matches were found.
+//
+// This is parameterized on a |Matcher| traits type, so that it can be the
+// implementation for both ReplaceChars() and ReplaceSubstringsAfterOffset().
+template <class StringType, class Matcher>
+bool DoReplaceMatchesAfterOffset(StringType* str,
+ size_t initial_offset,
+ Matcher matcher,
+ BasicStringPiece<StringType> replace_with,
+ ReplaceType replace_type) {
+ using CharTraits = typename StringType::traits_type;
+
+ const size_t find_length = matcher.MatchSize();
+ if (!find_length)
+ return false;
+
+ // If the find string doesn't appear, there's nothing to do.
+ size_t first_match = matcher.Find(*str, initial_offset);
+ if (first_match == StringType::npos)
+ return false;
+
+ // If we're only replacing one instance, there's no need to do anything
+ // complicated.
+ const size_t replace_length = replace_with.length();
+ if (replace_type == ReplaceType::REPLACE_FIRST) {
+ str->replace(first_match, find_length, replace_with.data(), replace_length);
+ return true;
+ }
+
+ // If the find and replace strings are the same length, we can simply use
+ // replace() on each instance, and finish the entire operation in O(n) time.
+ if (find_length == replace_length) {
+ auto* buffer = &((*str)[0]);
+ for (size_t offset = first_match; offset != StringType::npos;
+ offset = matcher.Find(*str, offset + replace_length)) {
+ CharTraits::copy(buffer + offset, replace_with.data(), replace_length);
+ }
+ return true;
+ }
+
+ // Since the find and replace strings aren't the same length, a loop like the
+ // one above would be O(n^2) in the worst case, as replace() will shift the
+ // entire remaining string each time. We need to be more clever to keep things
+ // O(n).
+ //
+ // When the string is being shortened, it's possible to just shift the matches
+ // down in one pass while finding, and truncate the length at the end of the
+ // search.
+ //
+ // If the string is being lengthened, more work is required. The strategy used
+ // here is to make two find() passes through the string. The first pass counts
+ // the number of matches to determine the new size. The second pass will
+ // either construct the new string into a new buffer (if the existing buffer
+ // lacked capacity), or else -- if there is room -- create a region of scratch
+ // space after |first_match| by shifting the tail of the string to a higher
+ // index, and doing in-place moves from the tail to lower indices thereafter.
+ size_t str_length = str->length();
+ size_t expansion = 0;
+ if (replace_length > find_length) {
+ // This operation lengthens the string; determine the new length by counting
+ // matches.
+ const size_t expansion_per_match = (replace_length - find_length);
+ size_t num_matches = 0;
+ for (size_t match = first_match; match != StringType::npos;
+ match = matcher.Find(*str, match + find_length)) {
+ expansion += expansion_per_match;
+ ++num_matches;
+ }
+ const size_t final_length = str_length + expansion;
+
+ if (str->capacity() < final_length) {
+ // If we'd have to allocate a new buffer to grow the string, build the
+ // result directly into the new allocation via append().
+ StringType src(str->get_allocator());
+ str->swap(src);
+ str->reserve(final_length);
+
+ size_t pos = 0;
+ for (size_t match = first_match;; match = matcher.Find(src, pos)) {
+ str->append(src, pos, match - pos);
+ str->append(replace_with.data(), replace_length);
+ pos = match + find_length;
+
+ // A mid-loop test/break enables skipping the final Find() call; the
+ // number of matches is known, so don't search past the last one.
+ if (!--num_matches)
+ break;
+ }
+
+ // Handle substring after the final match.
+ str->append(src, pos, str_length - pos);
+ return true;
+ }
+
+ // Prepare for the copy/move loop below -- expand the string to its final
+ // size by shifting the data after the first match to the end of the resized
+ // string.
+ size_t shift_src = first_match + find_length;
+ size_t shift_dst = shift_src + expansion;
+
+ // Big |expansion| factors (relative to |str_length|) require padding up to
+ // |shift_dst|.
+ if (shift_dst > str_length)
+ str->resize(shift_dst);
+
+ str->replace(shift_dst, str_length - shift_src, *str, shift_src,
+ str_length - shift_src);
+ str_length = final_length;
+ }
+
+ // We can alternate replacement and move operations. This won't overwrite the
+ // unsearched region of the string so long as |write_offset| <= |read_offset|;
+ // that condition is always satisfied because:
+ //
+ // (a) If the string is being shortened, |expansion| is zero and
+ // |write_offset| grows slower than |read_offset|.
+ //
+ // (b) If the string is being lengthened, |write_offset| grows faster than
+ // |read_offset|, but |expansion| is big enough so that |write_offset|
+ // will only catch up to |read_offset| at the point of the last match.
+ auto* buffer = &((*str)[0]);
+ size_t write_offset = first_match;
+ size_t read_offset = first_match + expansion;
+ do {
+ if (replace_length) {
+ CharTraits::copy(buffer + write_offset, replace_with.data(),
+ replace_length);
+ write_offset += replace_length;
+ }
+ read_offset += find_length;
+
+ // min() clamps StringType::npos (the largest unsigned value) to str_length.
+ size_t match = std::min(matcher.Find(*str, read_offset), str_length);
+
+ size_t length = match - read_offset;
+ if (length) {
+ CharTraits::move(buffer + write_offset, buffer + read_offset, length);
+ write_offset += length;
+ read_offset += length;
+ }
+ } while (read_offset < str_length);
+
+ // If we're shortening the string, truncate it now.
+ str->resize(write_offset);
+ return true;
+}
+
+template <class StringType>
+bool ReplaceCharsT(BasicStringPiece<StringType> input,
+ BasicStringPiece<StringType> find_any_of_these,
+ BasicStringPiece<StringType> replace_with,
+ StringType* output) {
+ // Commonly, this is called with output and input being the same string; in
+ // that case, skip the copy.
+ if (input.data() != output->data() || input.size() != output->size())
+ output->assign(input.data(), input.size());
+
+ return DoReplaceMatchesAfterOffset(
+ output, 0, CharacterMatcher<StringType>{find_any_of_these}, replace_with,
+ ReplaceType::REPLACE_ALL);
+}
+
+template <class string_type>
+inline typename string_type::value_type* WriteIntoT(string_type* str,
+ size_t length_with_null) {
+ GURL_DCHECK_GE(length_with_null, 1u);
+ str->reserve(length_with_null);
+ str->resize(length_with_null - 1);
+ return &((*str)[0]);
+}
+
+// Generic version for all JoinString overloads. |list_type| must be a sequence
+// (gurl_base::span or std::initializer_list) of strings/StringPieces (std::string,
+// string16, StringPiece or StringPiece16). |string_type| is either std::string
+// or string16.
+template <typename list_type, typename string_type>
+static string_type JoinStringT(list_type parts,
+ BasicStringPiece<string_type> sep) {
+ if (gurl_base::empty(parts))
+ return string_type();
+
+ // Pre-allocate the eventual size of the string. Start with the size of all of
+ // the separators (note that this *assumes* parts.size() > 0).
+ size_t total_size = (parts.size() - 1) * sep.size();
+ for (const auto& part : parts)
+ total_size += part.size();
+ string_type result;
+ result.reserve(total_size);
+
+ auto iter = parts.begin();
+ GURL_DCHECK(iter != parts.end());
+ result.append(iter->data(), iter->size());
+ ++iter;
+
+ for (; iter != parts.end(); ++iter) {
+ result.append(sep.data(), sep.size());
+ result.append(iter->data(), iter->size());
+ }
+
+ // Sanity-check that we pre-allocated correctly.
+ GURL_DCHECK_EQ(total_size, result.size());
+
+ return result;
+}
+
+template <class StringType>
+StringType DoReplaceStringPlaceholders(
+ BasicStringPiece<StringType> format_string,
+ const std::vector<StringType>& subst,
+ std::vector<size_t>* offsets) {
+ size_t substitutions = subst.size();
+ GURL_DCHECK_LT(substitutions, 10U);
+
+ size_t sub_length = 0;
+ for (const auto& cur : subst)
+ sub_length += cur.length();
+
+ StringType formatted;
+ formatted.reserve(format_string.length() + sub_length);
+
+ std::vector<ReplacementOffset> r_offsets;
+ for (auto i = format_string.begin(); i != format_string.end(); ++i) {
+ if ('$' == *i) {
+ if (i + 1 != format_string.end()) {
+ ++i;
+ if ('$' == *i) {
+ while (i != format_string.end() && '$' == *i) {
+ formatted.push_back('$');
+ ++i;
+ }
+ --i;
+ } else {
+ if (*i < '1' || *i > '9') {
+ GURL_DLOG(ERROR) << "Invalid placeholder: $" << *i;
+ continue;
+ }
+ uintptr_t index = *i - '1';
+ if (offsets) {
+ ReplacementOffset r_offset(index,
+ static_cast<int>(formatted.size()));
+ r_offsets.insert(
+ std::upper_bound(r_offsets.begin(), r_offsets.end(), r_offset,
+ &CompareParameter),
+ r_offset);
+ }
+ if (index < substitutions)
+ formatted.append(subst.at(index));
+ }
+ }
+ } else {
+ formatted.push_back(*i);
+ }
+ }
+ if (offsets) {
+ for (const auto& cur : r_offsets)
+ offsets->push_back(cur.offset);
+ }
+ return formatted;
+}
+
+// The following code is compatible with the OpenBSD lcpy interface. See:
+// http://www.gratisoft.us/todd/papers/strlcpy.html
+// ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/{wcs,str}lcpy.c
+
+template <typename CHAR>
+size_t lcpyT(CHAR* dst, const CHAR* src, size_t dst_size) {
+ for (size_t i = 0; i < dst_size; ++i) {
+ if ((dst[i] = src[i]) == 0) // We hit and copied the terminating NULL.
+ return i;
+ }
+
+ // We were left off at dst_size. We over copied 1 byte. Null terminate.
+ if (dst_size != 0)
+ dst[dst_size - 1] = 0;
+
+ // Count the rest of the |src|, and return it's length in characters.
+ while (src[dst_size])
+ ++dst_size;
+ return dst_size;
+}
+
+} // namespace internal
+
+} // namespace base
+
+#endif // BASE_STRINGS_STRING_UTIL_INTERNAL_H_
diff --git a/base/strings/string_util_posix.h b/base/strings/string_util_posix.h
index e1ba7c3..457e258 100644
--- a/base/strings/string_util_posix.h
+++ b/base/strings/string_util_posix.h
@@ -11,7 +11,7 @@
#include <string.h>
#include <wchar.h>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check.h"
namespace gurl_base {
diff --git a/base/strings/string_util_unittest.cc b/base/strings/string_util_unittest.cc
index a2aab42..f73b895 100644
--- a/base/strings/string_util_unittest.cc
+++ b/base/strings/string_util_unittest.cc
@@ -12,6 +12,7 @@
#include <algorithm>
#include <type_traits>
+#include "base/bits.h"
#include "base/stl_util.h"
#include "base/strings/string16.h"
#include "base/strings/utf_string_conversions.h"
@@ -678,28 +679,28 @@
int64_t bytes;
const char* expected;
} cases[] = {
- // Expected behavior: we show one post-decimal digit when we have
- // under two pre-decimal digits, except in cases where it makes no
- // sense (zero or bytes).
- // Since we switch units once we cross the 1000 mark, this keeps
- // the display of file sizes or bytes consistently around three
- // digits.
- {0, "0 B"},
- {512, "512 B"},
- {1024*1024, "1.0 MB"},
- {1024*1024*1024, "1.0 GB"},
- {10LL*1024*1024*1024, "10.0 GB"},
- {99LL*1024*1024*1024, "99.0 GB"},
- {105LL*1024*1024*1024, "105 GB"},
- {105LL*1024*1024*1024 + 500LL*1024*1024, "105 GB"},
- {~(1LL << 63), "8192 PB"},
+ // Expected behavior: we show one post-decimal digit when we have
+ // under two pre-decimal digits, except in cases where it makes no
+ // sense (zero or bytes).
+ // Since we switch units once we cross the 1000 mark, this keeps
+ // the display of file sizes or bytes consistently around three
+ // digits.
+ {0, "0 B"},
+ {512, "512 B"},
+ {1024 * 1024, "1.0 MB"},
+ {1024 * 1024 * 1024, "1.0 GB"},
+ {10LL * 1024 * 1024 * 1024, "10.0 GB"},
+ {99LL * 1024 * 1024 * 1024, "99.0 GB"},
+ {105LL * 1024 * 1024 * 1024, "105 GB"},
+ {105LL * 1024 * 1024 * 1024 + 500LL * 1024 * 1024, "105 GB"},
+ {~(bits::LeftmostBit<int64_t>()), "8192 PB"},
- {99*1024 + 103, "99.1 kB"},
- {1024*1024 + 103, "1.0 MB"},
- {1024*1024 + 205 * 1024, "1.2 MB"},
- {1024*1024*1024 + (927 * 1024*1024), "1.9 GB"},
- {10LL*1024*1024*1024, "10.0 GB"},
- {100LL*1024*1024*1024, "100 GB"},
+ {99 * 1024 + 103, "99.1 kB"},
+ {1024 * 1024 + 103, "1.0 MB"},
+ {1024 * 1024 + 205 * 1024, "1.2 MB"},
+ {1024 * 1024 * 1024 + (927 * 1024 * 1024), "1.9 GB"},
+ {10LL * 1024 * 1024 * 1024, "10.0 GB"},
+ {100LL * 1024 * 1024 * 1024, "100 GB"},
};
for (const auto& i : cases) {
diff --git a/base/strings/string_util_win.cc b/base/strings/string_util_win.cc
new file mode 100644
index 0000000..1a98101
--- /dev/null
+++ b/base/strings/string_util_win.cc
@@ -0,0 +1,145 @@
+// Copyright 2020 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.
+
+#include "base/strings/string_util_win.h"
+
+#include "base/strings/string_util_internal.h"
+
+namespace gurl_base {
+
+#if defined(BASE_STRING16_IS_STD_U16STRING)
+bool IsStringASCII(WStringPiece str) {
+ return internal::DoIsStringASCII(str.data(), str.length());
+}
+
+std::wstring ToLowerASCII(WStringPiece str) {
+ return internal::ToLowerASCIIImpl(str);
+}
+
+std::wstring ToUpperASCII(WStringPiece str) {
+ return internal::ToUpperASCIIImpl(str);
+}
+
+int CompareCaseInsensitiveASCII(WStringPiece a, WStringPiece b) {
+ return internal::CompareCaseInsensitiveASCIIT(a, b);
+}
+
+bool EqualsCaseInsensitiveASCII(WStringPiece a, WStringPiece b) {
+ return a.size() == b.size() &&
+ internal::CompareCaseInsensitiveASCIIT(a, b) == 0;
+}
+
+bool RemoveChars(WStringPiece input,
+ WStringPiece remove_chars,
+ std::wstring* output) {
+ return internal::ReplaceCharsT(input, remove_chars, WStringPiece(), output);
+}
+
+bool ReplaceChars(WStringPiece input,
+ WStringPiece replace_chars,
+ WStringPiece replace_with,
+ std::wstring* output) {
+ return internal::ReplaceCharsT(input, replace_chars, replace_with, output);
+}
+
+bool TrimString(WStringPiece input,
+ WStringPiece trim_chars,
+ std::wstring* output) {
+ return internal::TrimStringT(input, trim_chars, TRIM_ALL, output) !=
+ TRIM_NONE;
+}
+
+WStringPiece TrimString(WStringPiece input,
+ WStringPiece trim_chars,
+ TrimPositions positions) {
+ return internal::TrimStringPieceT(input, trim_chars, positions);
+}
+
+TrimPositions TrimWhitespace(WStringPiece input,
+ TrimPositions positions,
+ std::wstring* output) {
+ return internal::TrimStringT(input, WStringPiece(kWhitespaceWide), positions,
+ output);
+}
+
+WStringPiece TrimWhitespace(WStringPiece input, TrimPositions positions) {
+ return internal::TrimStringPieceT(input, WStringPiece(kWhitespaceWide),
+ positions);
+}
+
+std::wstring CollapseWhitespace(WStringPiece text,
+ bool trim_sequences_with_line_breaks) {
+ return internal::CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
+}
+
+bool ContainsOnlyChars(WStringPiece input, WStringPiece characters) {
+ return input.find_first_not_of(characters) == StringPiece::npos;
+}
+
+bool LowerCaseEqualsASCII(WStringPiece str, StringPiece lowercase_ascii) {
+ return internal::DoLowerCaseEqualsASCII(str, lowercase_ascii);
+}
+
+bool EqualsASCII(WStringPiece str, StringPiece ascii) {
+ return std::equal(ascii.begin(), ascii.end(), str.begin(), str.end());
+}
+
+bool StartsWith(WStringPiece str,
+ WStringPiece search_for,
+ CompareCase case_sensitivity) {
+ return internal::StartsWithT(str, search_for, case_sensitivity);
+}
+
+bool EndsWith(WStringPiece str,
+ WStringPiece search_for,
+ CompareCase case_sensitivity) {
+ return internal::EndsWithT(str, search_for, case_sensitivity);
+}
+
+void ReplaceFirstSubstringAfterOffset(std::wstring* str,
+ size_t start_offset,
+ WStringPiece find_this,
+ WStringPiece replace_with) {
+ internal::DoReplaceMatchesAfterOffset(
+ str, start_offset, internal::SubstringMatcher<std::wstring>{find_this},
+ replace_with, internal::ReplaceType::REPLACE_FIRST);
+}
+
+void ReplaceSubstringsAfterOffset(std::wstring* str,
+ size_t start_offset,
+ WStringPiece find_this,
+ WStringPiece replace_with) {
+ internal::DoReplaceMatchesAfterOffset(
+ str, start_offset, internal::SubstringMatcher<std::wstring>{find_this},
+ replace_with, internal::ReplaceType::REPLACE_ALL);
+}
+
+wchar_t* WriteInto(std::wstring* str, size_t length_with_null) {
+ return internal::WriteIntoT(str, length_with_null);
+}
+
+std::wstring JoinString(span<const std::wstring> parts,
+ WStringPiece separator) {
+ return internal::JoinStringT(parts, separator);
+}
+
+std::wstring JoinString(span<const WStringPiece> parts,
+ WStringPiece separator) {
+ return internal::JoinStringT(parts, separator);
+}
+
+std::wstring JoinString(std::initializer_list<WStringPiece> parts,
+ WStringPiece separator) {
+ return internal::JoinStringT(parts, separator);
+}
+
+std::wstring ReplaceStringPlaceholders(WStringPiece format_string,
+ const std::vector<std::wstring>& subst,
+ std::vector<size_t>* offsets) {
+ return internal::DoReplaceStringPlaceholders(format_string, subst, offsets);
+}
+
+#endif
+
+} // namespace base
diff --git a/base/strings/string_util_win.h b/base/strings/string_util_win.h
index 710d574..2765748 100644
--- a/base/strings/string_util_win.h
+++ b/base/strings/string_util_win.h
@@ -11,7 +11,14 @@
#include <string.h>
#include <wchar.h>
-#include "polyfills/base/logging.h"
+#include <string>
+#include <vector>
+
+#include "polyfills/base/check.h"
+#include "base/containers/span.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
namespace gurl_base {
@@ -39,6 +46,154 @@
return length;
}
+// Utility functions to access the underlying string buffer as a wide char
+// pointer.
+//
+// Note: These functions violate strict aliasing when char16 and wchar_t are
+// unrelated types. We thus pass -fno-strict-aliasing to the compiler on
+// non-Windows platforms [1], and rely on it being off in Clang's CL mode [2].
+//
+// [1] https://crrev.com/b9a0976622/build/config/compiler/BUILD.gn#244
+// [2]
+// https://github.com/llvm/llvm-project/blob/1e28a66/clang/lib/Driver/ToolChains/Clang.cpp#L3949
+inline wchar_t* as_writable_wcstr(char16* str) {
+ return reinterpret_cast<wchar_t*>(str);
+}
+
+inline wchar_t* as_writable_wcstr(string16& str) {
+ return reinterpret_cast<wchar_t*>(data(str));
+}
+
+inline const wchar_t* as_wcstr(const char16* str) {
+ return reinterpret_cast<const wchar_t*>(str);
+}
+
+inline const wchar_t* as_wcstr(StringPiece16 str) {
+ return reinterpret_cast<const wchar_t*>(str.data());
+}
+
+// Utility functions to access the underlying string buffer as a char16 pointer.
+inline char16* as_writable_u16cstr(wchar_t* str) {
+ return reinterpret_cast<char16*>(str);
+}
+
+inline char16* as_writable_u16cstr(std::wstring& str) {
+ return reinterpret_cast<char16*>(data(str));
+}
+
+inline const char16* as_u16cstr(const wchar_t* str) {
+ return reinterpret_cast<const char16*>(str);
+}
+
+inline const char16* as_u16cstr(WStringPiece str) {
+ return reinterpret_cast<const char16*>(str.data());
+}
+
+// Utility functions to convert between gurl_base::WStringPiece and
+// gurl_base::StringPiece16.
+inline WStringPiece AsWStringPiece(StringPiece16 str) {
+ return WStringPiece(as_wcstr(str.data()), str.size());
+}
+
+inline StringPiece16 AsStringPiece16(WStringPiece str) {
+ return StringPiece16(as_u16cstr(str.data()), str.size());
+}
+
+inline std::wstring AsWString(StringPiece16 str) {
+ return std::wstring(as_wcstr(str.data()), str.size());
+}
+
+inline string16 AsString16(WStringPiece str) {
+ return string16(as_u16cstr(str.data()), str.size());
+}
+
+// The following section contains overloads of the cross-platform APIs for
+// std::wstring and gurl_base::WStringPiece. These are only enabled if std::wstring
+// and gurl_base::string16 are distinct types, as otherwise this would result in an
+// ODR violation.
+// TODO(crbug.com/911896): Remove those guards once gurl_base::string16 is
+// std::u16string.
+#if defined(BASE_STRING16_IS_STD_U16STRING)
+BASE_EXPORT bool IsStringASCII(WStringPiece str);
+
+BASE_EXPORT std::wstring ToLowerASCII(WStringPiece str);
+
+BASE_EXPORT std::wstring ToUpperASCII(WStringPiece str);
+
+BASE_EXPORT int CompareCaseInsensitiveASCII(WStringPiece a, WStringPiece b);
+
+BASE_EXPORT bool EqualsCaseInsensitiveASCII(WStringPiece a, WStringPiece b);
+
+BASE_EXPORT bool RemoveChars(WStringPiece input,
+ WStringPiece remove_chars,
+ std::wstring* output);
+
+BASE_EXPORT bool ReplaceChars(WStringPiece input,
+ WStringPiece replace_chars,
+ WStringPiece replace_with,
+ std::wstring* output);
+
+BASE_EXPORT bool TrimString(WStringPiece input,
+ WStringPiece trim_chars,
+ std::string* output);
+
+BASE_EXPORT WStringPiece TrimString(WStringPiece input,
+ WStringPiece trim_chars,
+ TrimPositions positions);
+
+BASE_EXPORT TrimPositions TrimWhitespace(WStringPiece input,
+ TrimPositions positions,
+ std::wstring* output);
+
+BASE_EXPORT WStringPiece TrimWhitespace(WStringPiece input,
+ TrimPositions positions);
+
+BASE_EXPORT std::wstring CollapseWhitespace(
+ WStringPiece text,
+ bool trim_sequences_with_line_breaks);
+
+BASE_EXPORT bool ContainsOnlyChars(WStringPiece input, WStringPiece characters);
+
+BASE_EXPORT bool LowerCaseEqualsASCII(WStringPiece str,
+ StringPiece lowecase_ascii);
+
+BASE_EXPORT bool EqualsASCII(StringPiece16 str, StringPiece ascii);
+
+BASE_EXPORT bool StartsWith(WStringPiece str,
+ WStringPiece search_for,
+ CompareCase case_sensitivity);
+
+BASE_EXPORT bool EndsWith(WStringPiece str,
+ WStringPiece search_for,
+ CompareCase case_sensitivity);
+
+BASE_EXPORT void ReplaceFirstSubstringAfterOffset(std::wstring* str,
+ size_t start_offset,
+ WStringPiece find_this,
+ WStringPiece replace_with);
+
+BASE_EXPORT void ReplaceSubstringsAfterOffset(std::wstring* str,
+ size_t start_offset,
+ WStringPiece find_this,
+ WStringPiece replace_with);
+
+BASE_EXPORT wchar_t* WriteInto(std::wstring* str, size_t length_with_null);
+
+BASE_EXPORT std::wstring JoinString(span<const std::wstring> parts,
+ WStringPiece separator);
+
+BASE_EXPORT std::wstring JoinString(span<const WStringPiece> parts,
+ WStringPiece separator);
+
+BASE_EXPORT std::wstring JoinString(std::initializer_list<WStringPiece> parts,
+ WStringPiece separator);
+
+BASE_EXPORT std::wstring ReplaceStringPlaceholders(
+ WStringPiece format_string,
+ const std::vector<string16>& subst,
+ std::vector<size_t>* offsets);
+#endif
+
} // namespace base
#endif // BASE_STRINGS_STRING_UTIL_WIN_H_
diff --git a/base/strings/stringprintf.cc b/base/strings/stringprintf.cc
index cc58087..e1a18c9 100644
--- a/base/strings/stringprintf.cc
+++ b/base/strings/stringprintf.cc
@@ -9,6 +9,7 @@
#include <vector>
+#include "polyfills/base/logging.h"
#include "base/scoped_clear_last_error.h"
#include "base/stl_util.h"
#include "base/strings/string_util.h"
@@ -62,7 +63,7 @@
va_list ap_copy;
va_copy(ap_copy, ap);
- gurl_base::internal::ScopedClearLastError last_error;
+ gurl_base::ScopedClearLastError last_error;
int result = vsnprintfT(stack_buf, gurl_base::size(stack_buf), format, ap_copy);
va_end(ap_copy);
diff --git a/base/strings/sys_string_conversions.h b/base/strings/sys_string_conversions.h
index 7c3c575..a2b4cce 100644
--- a/base/strings/sys_string_conversions.h
+++ b/base/strings/sys_string_conversions.h
@@ -20,6 +20,9 @@
#if defined(OS_MACOSX)
#include <CoreFoundation/CoreFoundation.h>
+
+#include "base/mac/scoped_cftyperef.h"
+
#ifdef __OBJC__
@class NSString;
#else
@@ -66,10 +69,10 @@
// Creates a string, and returns it with a refcount of 1. You are responsible
// for releasing it. Returns NULL on failure.
-BASE_EXPORT CFStringRef SysUTF8ToCFStringRef(StringPiece utf8)
+BASE_EXPORT ScopedCFTypeRef<CFStringRef> SysUTF8ToCFStringRef(StringPiece utf8)
WARN_UNUSED_RESULT;
-BASE_EXPORT CFStringRef SysUTF16ToCFStringRef(StringPiece16 utf16)
- WARN_UNUSED_RESULT;
+BASE_EXPORT ScopedCFTypeRef<CFStringRef> SysUTF16ToCFStringRef(
+ StringPiece16 utf16) WARN_UNUSED_RESULT;
// Same, but returns an autoreleased NSString.
BASE_EXPORT NSString* SysUTF8ToNSString(StringPiece utf8) WARN_UNUSED_RESULT;
diff --git a/base/strings/sys_string_conversions_posix.cc b/base/strings/sys_string_conversions_posix.cc
index 80f01e6..f9f7312 100644
--- a/base/strings/sys_string_conversions_posix.cc
+++ b/base/strings/sys_string_conversions_posix.cc
@@ -5,6 +5,7 @@
#include "base/strings/sys_string_conversions.h"
#include <stddef.h>
+#include <string.h>
#include <wchar.h>
#include "base/strings/string_piece.h"
@@ -57,7 +58,6 @@
// Handle any errors and return an empty string.
case static_cast<size_t>(-1):
return std::string();
- break;
case 0:
// We hit an embedded null byte, keep going.
++num_out_chars;
@@ -85,7 +85,6 @@
// Handle any errors and return an empty string.
case static_cast<size_t>(-1):
return std::string();
- break;
case 0:
// We hit an embedded null byte, keep going.
++j; // Output is already zeroed.
@@ -114,7 +113,6 @@
case static_cast<size_t>(-2):
case static_cast<size_t>(-1):
return std::wstring();
- break;
case 0:
// We hit an embedded null byte, keep going.
i += 1;
@@ -144,7 +142,6 @@
case static_cast<size_t>(-2):
case static_cast<size_t>(-1):
return std::wstring();
- break;
case 0:
i += 1; // Skip null byte.
break;
diff --git a/base/strings/utf_offset_string_conversions.cc b/base/strings/utf_offset_string_conversions.cc
index 7d00bb4..5a492d6 100644
--- a/base/strings/utf_offset_string_conversions.cc
+++ b/base/strings/utf_offset_string_conversions.cc
@@ -9,7 +9,7 @@
#include <algorithm>
#include <memory>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check_op.h"
#include "base/strings/string_piece.h"
#include "base/strings/utf_string_conversion_utils.h"
diff --git a/base/strings/utf_offset_string_conversions_unittest.cc b/base/strings/utf_offset_string_conversions_unittest.cc
index 4691cb3..8416524 100644
--- a/base/strings/utf_offset_string_conversions_unittest.cc
+++ b/base/strings/utf_offset_string_conversions_unittest.cc
@@ -6,7 +6,6 @@
#include <algorithm>
-#include "polyfills/base/logging.h"
#include "base/stl_util.h"
#include "base/strings/string_piece.h"
#include "base/strings/utf_offset_string_conversions.h"
diff --git a/base/strings/utf_string_conversions.cc b/base/strings/utf_string_conversions.cc
index aaf4a40..92333e2 100644
--- a/base/strings/utf_string_conversions.cc
+++ b/base/strings/utf_string_conversions.cc
@@ -339,4 +339,16 @@
return std::string(utf16.begin(), utf16.end());
}
+#if defined(WCHAR_T_IS_UTF16)
+std::wstring ASCIIToWide(StringPiece ascii) {
+ GURL_DCHECK(IsStringASCII(ascii)) << ascii;
+ return std::wstring(ascii.begin(), ascii.end());
+}
+
+std::string WideToASCII(WStringPiece wide) {
+ GURL_DCHECK(IsStringASCII(wide)) << wide;
+ return std::string(wide.begin(), wide.end());
+}
+#endif // defined(WCHAR_T_IS_UTF16)
+
} // namespace base
diff --git a/base/strings/utf_string_conversions.h b/base/strings/utf_string_conversions.h
index 745372c..043b6ae 100644
--- a/base/strings/utf_string_conversions.h
+++ b/base/strings/utf_string_conversions.h
@@ -12,6 +12,7 @@
#include "polyfills/base/base_export.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
+#include "build/build_config.h"
namespace gurl_base {
@@ -49,6 +50,16 @@
// beforehand.
BASE_EXPORT std::string UTF16ToASCII(StringPiece16 utf16) WARN_UNUSED_RESULT;
+#if defined(WCHAR_T_IS_UTF16)
+// This converts an ASCII string, typically a hardcoded constant, to a wide
+// string.
+BASE_EXPORT std::wstring ASCIIToWide(StringPiece ascii) WARN_UNUSED_RESULT;
+
+// Converts to 7-bit ASCII by truncating. The result must be known to be ASCII
+// beforehand.
+BASE_EXPORT std::string WideToASCII(WStringPiece wide) WARN_UNUSED_RESULT;
+#endif // defined(WCHAR_T_IS_UTF16)
+
} // namespace base
#endif // BASE_STRINGS_UTF_STRING_CONVERSIONS_H_
diff --git a/base/strings/utf_string_conversions_unittest.cc b/base/strings/utf_string_conversions_unittest.cc
index 22b167b..6cffe99 100644
--- a/base/strings/utf_string_conversions_unittest.cc
+++ b/base/strings/utf_string_conversions_unittest.cc
@@ -4,7 +4,6 @@
#include <stddef.h>
-#include "polyfills/base/logging.h"
#include "base/stl_util.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
diff --git a/base/template_util.h b/base/template_util.h
index 5384355..8c2b185 100644
--- a/base/template_util.h
+++ b/base/template_util.h
@@ -180,6 +180,50 @@
static constexpr bool value = true;
};
+// C++14 implementation of C++17's std::bool_constant.
+//
+// Reference: https://en.cppreference.com/w/cpp/types/integral_constant
+// Specification: https://wg21.link/meta.type.synop
+template <bool B>
+using bool_constant = std::integral_constant<bool, B>;
+
+// C++14 implementation of C++17's std::conjunction.
+//
+// Reference: https://en.cppreference.com/w/cpp/types/conjunction
+// Specification: https://wg21.link/meta.logical#1.itemdecl:1
+template <typename...>
+struct conjunction : std::true_type {};
+
+template <typename B1>
+struct conjunction<B1> : B1 {};
+
+template <typename B1, typename... Bn>
+struct conjunction<B1, Bn...>
+ : std::conditional_t<static_cast<bool>(B1::value), conjunction<Bn...>, B1> {
+};
+
+// C++14 implementation of C++17's std::disjunction.
+//
+// Reference: https://en.cppreference.com/w/cpp/types/disjunction
+// Specification: https://wg21.link/meta.logical#itemdecl:2
+template <typename...>
+struct disjunction : std::false_type {};
+
+template <typename B1>
+struct disjunction<B1> : B1 {};
+
+template <typename B1, typename... Bn>
+struct disjunction<B1, Bn...>
+ : std::conditional_t<static_cast<bool>(B1::value), B1, disjunction<Bn...>> {
+};
+
+// C++14 implementation of C++17's std::negation.
+//
+// Reference: https://en.cppreference.com/w/cpp/types/negation
+// Specification: https://wg21.link/meta.logical#itemdecl:3
+template <typename B>
+struct negation : bool_constant<!static_cast<bool>(B::value)> {};
+
} // namespace base
#undef CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
diff --git a/build/build_config.h b/build/build_config.h
index 688b779..6a6028d 100644
--- a/build/build_config.h
+++ b/build/build_config.h
@@ -64,7 +64,7 @@
#elif defined(_AIX)
#define OS_AIX 1
#elif defined(__asmjs__) || defined(__wasm__)
-#define OS_ASMJS
+#define OS_ASMJS 1
#else
#error Please add support for your platform in build/build_config.h
#endif
@@ -86,7 +86,8 @@
#define OS_POSIX 1
#endif
-// Compiler detection.
+// Compiler detection. Note: clang masquerades as GCC on POSIX and as MSVC on
+// Windows.
#if defined(__GNUC__)
#define COMPILER_GCC 1
#elif defined(_MSC_VER)
diff --git a/copy.bara.sky b/copy.bara.sky
index 02a615d..328fbab 100644
--- a/copy.bara.sky
+++ b/copy.bara.sky
@@ -13,6 +13,9 @@
"AUTHORS",
"LICENSE",
"base/compiler_specific.h",
+ "base/containers/checked_iterators.h",
+ "base/containers/span.h",
+ "base/containers/util.h",
"base/macros.h",
"base/debug/leak_annotations.h",
"base/no_destructor.h",
@@ -49,10 +52,13 @@
# Should be in sync with //polyfill/BUILD.
polyfilled_headers = [
"base/base_export.h",
+ "base/check.h",
+ "base/check_op.h",
"base/component_export.h",
"base/debug/alias.h",
"base/export_template.h",
"base/logging.h",
+ "base/notreached.h",
"base/trace_event/memory_usage_estimator.h",
]
diff --git a/polyfills/BUILD b/polyfills/BUILD
index beeac1a..820c63d 100644
--- a/polyfills/BUILD
+++ b/polyfills/BUILD
@@ -7,10 +7,13 @@
name = "polyfills",
hdrs = [
"base/base_export.h",
+ "base/check.h",
+ "base/check_op.h",
"base/component_export.h",
"base/debug/alias.h",
"base/export_template.h",
"base/logging.h",
+ "base/notreached.h",
"base/trace_event/memory_usage_estimator.h",
],
copts = build_config.default_copts,
diff --git a/polyfills/base/check.h b/polyfills/base/check.h
new file mode 100644
index 0000000..15de08b
--- /dev/null
+++ b/polyfills/base/check.h
@@ -0,0 +1,10 @@
+// Copyright (c) 2020 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 POLYFILLS_BASE_CHECK_H_
+#define POLYFILLS_BASE_CHECK_H_
+
+#include "polyfills/base/logging.h"
+
+#endif /* POLYFILLS_BASE_CHECK_H_ */
diff --git a/polyfills/base/check_op.h b/polyfills/base/check_op.h
new file mode 100644
index 0000000..ecc127a
--- /dev/null
+++ b/polyfills/base/check_op.h
@@ -0,0 +1,10 @@
+// Copyright (c) 2020 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 POLYFILLS_BASE_CHECK_OP_H_
+#define POLYFILLS_BASE_CHECK_OP_H_
+
+#include "polyfills/base/logging.h"
+
+#endif /* POLYFILLS_BASE_CHECK_OP_H_ */
diff --git a/polyfills/base/logging.h b/polyfills/base/logging.h
index 41ddacd..afe296e 100644
--- a/polyfills/base/logging.h
+++ b/polyfills/base/logging.h
@@ -20,8 +20,10 @@
GurlFakeLogSink& operator<<(const T&) { return *this; }
};
+#define GURL_CHECK_GE(statement, statement2) GurlFakeLogSink({statement, statement2})
#define GURL_CHECK_LE(statement, statement2) GurlFakeLogSink({statement, statement2})
#define GURL_CHECK_NE(statement, statement2) GurlFakeLogSink({statement, statement2})
+#define GURL_CHECK_EQ(statement, statement2) GurlFakeLogSink({statement, statement2})
#define GURL_CHECK(statement) GurlFakeLogSink({statement})
#define GURL_DCHECK_EQ(statement, statement2) GurlFakeLogSink({statement, statement2})
#define GURL_DCHECK_GE(statement, statement2) GurlFakeLogSink({statement, statement2})
diff --git a/polyfills/base/notreached.h b/polyfills/base/notreached.h
new file mode 100644
index 0000000..564d64c
--- /dev/null
+++ b/polyfills/base/notreached.h
@@ -0,0 +1,10 @@
+// Copyright (c) 2020 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 POLYFILLS_BASE_NOTREACHED_H_
+#define POLYFILLS_BASE_NOTREACHED_H_
+
+#include "polyfills/base/logging.h"
+
+#endif /* POLYFILLS_BASE_NOTREACHED_H_ */
diff --git a/url/gurl.cc b/url/gurl.cc
index 36c5ee2..5ac3ea1 100644
--- a/url/gurl.cc
+++ b/url/gurl.cc
@@ -10,7 +10,7 @@
#include <ostream>
#include <utility>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check_op.h"
#include "base/no_destructor.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
@@ -288,7 +288,7 @@
}
GURL GURL::GetAsReferrer() const {
- if (!SchemeIsValidForReferrer())
+ if (!is_valid() || !IsReferrerScheme(spec_.data(), parsed_.scheme))
return GURL();
if (!has_ref() && !has_username() && !has_password())
@@ -354,10 +354,6 @@
return SchemeIs(url::kHttpScheme) || SchemeIs(url::kHttpsScheme);
}
-bool GURL::SchemeIsValidForReferrer() const {
- return is_valid_ && IsReferrerScheme(spec_.data(), parsed_.scheme);
-}
-
bool GURL::SchemeIsWSOrWSS() const {
return SchemeIs(url::kWsScheme) || SchemeIs(url::kWssScheme);
}
@@ -519,7 +515,9 @@
}
bool operator==(const GURL& x, const gurl_base::StringPiece& spec) {
- GURL_DCHECK_EQ(GURL(spec).possibly_invalid_spec(), spec);
+ GURL_DCHECK_EQ(GURL(spec).possibly_invalid_spec(), spec)
+ << "Comparisons of GURLs and strings must ensure as a precondition that "
+ "the string is fully canonicalized.";
return x.possibly_invalid_spec() == spec;
}
diff --git a/url/gurl.h b/url/gurl.h
index 73d2b43..aa33094 100644
--- a/url/gurl.h
+++ b/url/gurl.h
@@ -229,9 +229,6 @@
// Returns true if the scheme is "http" or "https".
bool SchemeIsHTTPOrHTTPS() const;
- // Returns true if the scheme is valid for use as a referrer.
- bool SchemeIsValidForReferrer() const;
-
// Returns true is the scheme is "ws" or "wss".
bool SchemeIsWSOrWSS() const;
diff --git a/url/gurl_fuzzer.cc b/url/gurl_fuzzer.cc
index 71f3540..a07c195 100644
--- a/url/gurl_fuzzer.cc
+++ b/url/gurl_fuzzer.cc
@@ -15,6 +15,9 @@
TestCase* test_case = new TestCase();
+// Empty replacements cause no change when applied.
+GURL::Replacements* no_op = new GURL::Replacements();
+
// Entry point for LibFuzzer.
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
if (size < 1)
@@ -23,6 +26,13 @@
gurl_base::StringPiece string_piece_input(reinterpret_cast<const char*>(data),
size);
GURL url_from_string_piece(string_piece_input);
+ // Copying by applying empty replacements exercises interesting code paths.
+ // This can help discover issues like https://crbug.com/1075515.
+ GURL copy = url_from_string_piece.ReplaceComponents(*no_op);
+ GURL_CHECK_EQ(url_from_string_piece.is_valid(), copy.is_valid());
+ if (url_from_string_piece.is_valid()) {
+ GURL_CHECK_EQ(url_from_string_piece.spec(), copy.spec());
+ }
// Test for StringPiece16 if size is even.
if (size % 2 == 0) {
diff --git a/url/gurl_unittest.cc b/url/gurl_unittest.cc
index b114920..1030416 100644
--- a/url/gurl_unittest.cc
+++ b/url/gurl_unittest.cc
@@ -5,9 +5,11 @@
#include <stddef.h>
#include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
+#include "url/origin.h"
#include "url/url_canon.h"
#include "url/url_test_utils.h"
@@ -223,16 +225,17 @@
TEST(GURLTest, IsValid) {
const char* valid_cases[] = {
- "http://google.com",
- "unknown://google.com",
- "http://user:pass@google.com",
- "http://google.com:12345",
- "http://google.com/path",
- "http://google.com//path",
- "http://google.com?k=v#fragment",
- "http://user:pass@google.com:12345/path?k=v#fragment",
- "http:/path",
- "http:path",
+ "http://google.com",
+ "unknown://google.com",
+ "http://user:pass@google.com",
+ "http://google.com:12345",
+ "http://google.com:0", // 0 is a valid port
+ "http://google.com/path",
+ "http://google.com//path",
+ "http://google.com?k=v#fragment",
+ "http://user:pass@google.com:12345/path?k=v#fragment",
+ "http:/path",
+ "http:path",
};
for (size_t i = 0; i < gurl_base::size(valid_cases); i++) {
EXPECT_TRUE(GURL(valid_cases[i]).is_valid())
@@ -240,12 +243,14 @@
}
const char* invalid_cases[] = {
- "http://?k=v",
- "http:://google.com",
- "http//google.com",
- "http://google.com:12three45",
- "://google.com",
- "path",
+ "http://?k=v",
+ "http:://google.com",
+ "http//google.com",
+ "http://google.com:12three45",
+ "file://server:123", // file: URLs cannot have a port
+ "file://server:0",
+ "://google.com",
+ "path",
};
for (size_t i = 0; i < gurl_base::size(invalid_cases); i++) {
EXPECT_FALSE(GURL(invalid_cases[i]).is_valid())
@@ -979,4 +984,43 @@
EXPECT_STREQ("https://foo.com/bar", url_debug_alias);
}
+TEST(GURLTest, PortZero) {
+ GURL port_zero_url("http://127.0.0.1:0/blah");
+
+ // https://url.spec.whatwg.org/#port-state says that the port 1) consists of
+ // ASCII digits (this excludes negative numbers) and 2) cannot be greater than
+ // 2^16-1. This means that port=0 should be valid.
+ EXPECT_TRUE(port_zero_url.is_valid());
+ EXPECT_EQ("0", port_zero_url.port());
+ EXPECT_EQ("127.0.0.1", port_zero_url.host());
+ EXPECT_EQ("http", port_zero_url.scheme());
+
+ // https://crbug.com/1065532: SchemeHostPort would previously incorrectly
+ // consider port=0 to be invalid.
+ SchemeHostPort scheme_host_port(port_zero_url);
+ EXPECT_TRUE(scheme_host_port.IsValid());
+ EXPECT_EQ(port_zero_url.scheme(), scheme_host_port.scheme());
+ EXPECT_EQ(port_zero_url.host(), scheme_host_port.host());
+ EXPECT_EQ(port_zero_url.port(),
+ gurl_base::NumberToString(scheme_host_port.port()));
+
+ // https://crbug.com/1065532: The SchemeHostPort problem above would lead to
+ // bizarre results below - resolved origin would incorrectly be returned as an
+ // opaque origin derived from |another_origin|.
+ url::Origin another_origin = url::Origin::Create(GURL("http://other.com"));
+ url::Origin resolved_origin =
+ url::Origin::Resolve(port_zero_url, another_origin);
+ EXPECT_FALSE(resolved_origin.opaque());
+ EXPECT_EQ(port_zero_url.scheme(), resolved_origin.scheme());
+ EXPECT_EQ(port_zero_url.host(), resolved_origin.host());
+ EXPECT_EQ(port_zero_url.port(), gurl_base::NumberToString(resolved_origin.port()));
+
+ // port=0 and default HTTP port are different.
+ GURL default_port("http://127.0.0.1/foo");
+ EXPECT_EQ(0, SchemeHostPort(port_zero_url).port());
+ EXPECT_EQ(80, SchemeHostPort(default_port).port());
+ url::Origin default_port_origin = url::Origin::Create(default_port);
+ EXPECT_FALSE(default_port_origin.IsSameOriginWith(resolved_origin));
+}
+
} // namespace url
diff --git a/url/origin.cc b/url/origin.cc
index 16e93b0..574c512 100644
--- a/url/origin.cc
+++ b/url/origin.cc
@@ -10,8 +10,8 @@
#include <vector>
#include "base/base64.h"
+#include "polyfills/base/check_op.h"
#include "base/containers/span.h"
-#include "polyfills/base/logging.h"
#include "base/pickle.h"
#include "base/stl_util.h"
#include "base/strings/strcat.h"
@@ -65,10 +65,10 @@
return base_origin.DeriveNewOpaqueOrigin();
}
-Origin::Origin(const Origin& other) = default;
-Origin& Origin::operator=(const Origin& other) = default;
-Origin::Origin(Origin&& other) = default;
-Origin& Origin::operator=(Origin&& other) = default;
+Origin::Origin(const Origin&) = default;
+Origin& Origin::operator=(const Origin&) = default;
+Origin::Origin(Origin&&) noexcept = default;
+Origin& Origin::operator=(Origin&&) noexcept = default;
Origin::~Origin() = default;
// static
@@ -376,7 +376,7 @@
return Origin::Create(a).IsSameOriginWith(Origin::Create(b));
}
-Origin::Nonce::Nonce() {}
+Origin::Nonce::Nonce() = default;
Origin::Nonce::Nonce(const gurl_base::UnguessableToken& token) : token_(token) {
GURL_CHECK(!token_.is_empty());
}
diff --git a/url/origin.h b/url/origin.h
index 351c482..2aef330 100644
--- a/url/origin.h
+++ b/url/origin.h
@@ -172,8 +172,8 @@
// Copyable and movable.
Origin(const Origin&);
Origin& operator=(const Origin&);
- Origin(Origin&&);
- Origin& operator=(Origin&&);
+ Origin(Origin&&) noexcept;
+ Origin& operator=(Origin&&) noexcept;
// Creates an Origin from a |scheme|, |host|, and |port|. All the parameters
// must be valid and canonicalized. Returns nullopt if any parameter is not
@@ -338,8 +338,8 @@
// moving it does not.
Nonce(const Nonce&);
Nonce& operator=(const Nonce&);
- Nonce(Nonce&&);
- Nonce& operator=(Nonce&&);
+ Nonce(Nonce&&) noexcept;
+ Nonce& operator=(Nonce&&) noexcept;
// Note that operator<, used by maps type containers, will trigger |token_|
// lazy-initialization. Equality comparisons do not.
diff --git a/url/origin_unittest.cc b/url/origin_unittest.cc
index 514169b..8fe1cef 100644
--- a/url/origin_unittest.cc
+++ b/url/origin_unittest.cc
@@ -5,7 +5,6 @@
#include <stddef.h>
#include <stdint.h>
-#include "polyfills/base/logging.h"
#include "base/macros.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -483,7 +482,8 @@
{"http", "example.com", 123},
{"https", "example.com", 443},
{"https", "example.com", 123},
- {"file", "", 0},
+ {"http", "example.com", 0}, // 0 is a valid port for http.
+ {"file", "", 0}, // 0 indicates "no port" for file: scheme.
{"file", "example.com", 0},
};
@@ -539,12 +539,10 @@
{"http", "example.com\rnot-example.com"},
{"http", "example.com\n"},
{"http", "example.com\r"},
- {"http", "example.com", 0},
{"unknown-scheme", "example.com"},
{"host-only", "\r", 0},
{"host-only", "example.com", 22},
- {"host-port-only", "example.com", 0},
- {"file", ""}};
+ {"file", "", 123}}; // file: shouldn't have a port.
for (const auto& test : cases) {
SCOPED_TRACE(testing::Message()
diff --git a/url/scheme_host_port.cc b/url/scheme_host_port.cc
index c90e0a7..c541cae 100644
--- a/url/scheme_host_port.cc
+++ b/url/scheme_host_port.cc
@@ -9,7 +9,8 @@
#include <tuple>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check_op.h"
+#include "polyfills/base/notreached.h"
#include "base/numerics/safe_conversions.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
@@ -79,10 +80,12 @@
switch (scheme_type) {
case SCHEME_WITH_HOST_AND_PORT:
case SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION:
- // A URL with |scheme| is required to have the host and port (may be
- // omitted in a serialization if it's the same as the default value).
- // Return an invalid instance if either of them is not given.
- if (host.empty() || port == 0)
+ // A URL with |scheme| is required to have the host and port, so return an
+ // invalid instance if host is not given. Note that a valid port is
+ // always provided by SchemeHostPort(const GURL&) constructor (a missing
+ // port is replaced with a default port if needed by
+ // GURL::EffectiveIntPort()).
+ if (host.empty())
return false;
// Don't do an expensive canonicalization if the host is already
@@ -125,14 +128,12 @@
} // namespace
-SchemeHostPort::SchemeHostPort() : port_(0) {
-}
+SchemeHostPort::SchemeHostPort() = default;
SchemeHostPort::SchemeHostPort(std::string scheme,
std::string host,
uint16_t port,
- ConstructPolicy policy)
- : port_(0) {
+ ConstructPolicy policy) {
if (!IsValidInput(scheme, host, port, policy)) {
GURL_DCHECK(!IsValid());
return;
@@ -153,7 +154,7 @@
port,
ConstructPolicy::CHECK_CANONICALIZATION) {}
-SchemeHostPort::SchemeHostPort(const GURL& url) : port_(0) {
+SchemeHostPort::SchemeHostPort(const GURL& url) {
if (!url.is_valid())
return;
diff --git a/url/scheme_host_port.h b/url/scheme_host_port.h
index 903a398..8d5acd9 100644
--- a/url/scheme_host_port.h
+++ b/url/scheme_host_port.h
@@ -80,8 +80,8 @@
// Creates a (scheme, host, port) tuple. |host| must be a canonicalized
// A-label (that is, '☃.net' must be provided as 'xn--n3h.net'). |scheme|
- // must be a standard scheme. |port| must not be 0, unless |scheme| does not
- // support ports (e.g. 'file'). In that case, |port| must be 0.
+ // must be a standard scheme. |port| must be 0 if |scheme| does not support
+ // ports (e.g. 'file').
//
// Copies the data in |scheme| and |host|.
SchemeHostPort(gurl_base::StringPiece scheme,
@@ -111,8 +111,8 @@
// Copyable and movable.
SchemeHostPort(const SchemeHostPort&) = default;
SchemeHostPort& operator=(const SchemeHostPort&) = default;
- SchemeHostPort(SchemeHostPort&&) = default;
- SchemeHostPort& operator=(SchemeHostPort&&) = default;
+ SchemeHostPort(SchemeHostPort&&) noexcept = default;
+ SchemeHostPort& operator=(SchemeHostPort&&) noexcept = default;
~SchemeHostPort();
@@ -158,7 +158,7 @@
std::string scheme_;
std::string host_;
- uint16_t port_;
+ uint16_t port_ = 0;
};
COMPONENT_EXPORT(URL)
diff --git a/url/scheme_host_port_unittest.cc b/url/scheme_host_port_unittest.cc
index e3bcade..3e7bf65 100644
--- a/url/scheme_host_port_unittest.cc
+++ b/url/scheme_host_port_unittest.cc
@@ -91,9 +91,10 @@
} cases[] = {
{"http", "example.com", 80},
{"http", "example.com", 123},
+ {"http", "example.com", 0}, // 0 is a valid port for http.
{"https", "example.com", 443},
{"https", "example.com", 123},
- {"file", "", 0},
+ {"file", "", 0}, // 0 indicates "no port" for file: scheme.
{"file", "example.com", 0},
};
@@ -130,8 +131,7 @@
{"http", "example.com\rnot-example.com", 80},
{"http", "example.com\n", 80},
{"http", "example.com\r", 80},
- {"http", "example.com", 0},
- {"file", "", 80}};
+ {"file", "", 80}}; // Can''t have a port for file: scheme.
for (const auto& test : cases) {
SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
diff --git a/url/third_party/mozilla/url_parse.cc b/url/third_party/mozilla/url_parse.cc
index 8756cf7..4fd3a8e 100644
--- a/url/third_party/mozilla/url_parse.cc
+++ b/url/third_party/mozilla/url_parse.cc
@@ -38,7 +38,7 @@
#include <stdlib.h>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check_op.h"
#include "url/url_parse_internal.h"
#include "url/url_util.h"
#include "url/url_util_internal.h"
diff --git a/url/url_canon.h b/url/url_canon.h
index 7e4a0ee..c50cceb 100644
--- a/url/url_canon.h
+++ b/url/url_canon.h
@@ -28,8 +28,7 @@
template<typename T>
class CanonOutputT {
public:
- CanonOutputT() : buffer_(NULL), buffer_len_(0), cur_len_(0) {
- }
+ CanonOutputT() : buffer_(nullptr), buffer_len_(0), cur_len_(0) {}
virtual ~CanonOutputT() {
}
@@ -698,15 +697,14 @@
// will make them all NULL, which is no replacement. The caller would then
// override the components they want to replace.
URLComponentSource()
- : scheme(NULL),
- username(NULL),
- password(NULL),
- host(NULL),
- port(NULL),
- path(NULL),
- query(NULL),
- ref(NULL) {
- }
+ : scheme(nullptr),
+ username(nullptr),
+ password(nullptr),
+ host(nullptr),
+ port(nullptr),
+ path(nullptr),
+ query(nullptr),
+ ref(nullptr) {}
// Constructor normally used internally to initialize all the components to
// point to the same spec.
diff --git a/url/url_canon_filesystemurl.cc b/url/url_canon_filesystemurl.cc
index 9def892..9a642cd 100644
--- a/url/url_canon_filesystemurl.cc
+++ b/url/url_canon_filesystemurl.cc
@@ -39,7 +39,7 @@
output->Append("filesystem:", 11);
new_parsed->scheme.len = 10;
- if (!parsed.inner_parsed() || !parsed.inner_parsed()->scheme.is_valid())
+ if (!inner_parsed || !inner_parsed->scheme.is_valid())
return false;
bool success = true;
@@ -57,8 +57,8 @@
inner_scheme_type = SCHEME_WITH_HOST_AND_PORT;
}
success = CanonicalizeStandardURL(
- spec, parsed.inner_parsed()->Length(), *parsed.inner_parsed(),
- inner_scheme_type, charset_converter, output, &new_inner_parsed);
+ spec, inner_parsed->Length(), *inner_parsed, inner_scheme_type,
+ charset_converter, output, &new_inner_parsed);
} else {
// TODO(ericu): The URL is wrong, but should we try to output more of what
// we were given? Echoing back filesystem:mailto etc. doesn't seem all that
@@ -66,7 +66,7 @@
return false;
}
// The filesystem type must be more than just a leading slash for validity.
- success &= parsed.inner_parsed()->path.len > 1;
+ success &= new_inner_parsed.path.len > 1;
success &= CanonicalizePath(source.path, parsed.path, output,
&new_parsed->path);
diff --git a/url/url_canon_fileurl.cc b/url/url_canon_fileurl.cc
index ef654c7..4622c6e 100644
--- a/url/url_canon_fileurl.cc
+++ b/url/url_canon_fileurl.cc
@@ -76,8 +76,8 @@
Component sub_path = MakeRange(after_drive, path.end());
Component fake_output_path;
success = CanonicalizePath(spec, sub_path, output, &fake_output_path);
- } else {
- // No input path, canonicalize to a slash.
+ } else if (after_drive == path.begin) {
+ // No input path and no drive spec, canonicalize to a slash.
output->push_back('/');
}
diff --git a/url/url_canon_host.cc b/url/url_canon_host.cc
index f83dacb..28a7c38 100644
--- a/url/url_canon_host.cc
+++ b/url/url_canon_host.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check.h"
#include "url/url_canon.h"
#include "url/url_canon_internal.h"
diff --git a/url/url_canon_icu.cc b/url/url_canon_icu.cc
index a9a32fd..614e338 100644
--- a/url/url_canon_icu.cc
+++ b/url/url_canon_icu.cc
@@ -8,7 +8,7 @@
#include <stdlib.h>
#include <string.h>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check.h"
#include <unicode/ucnv.h>
#include <unicode/ucnv_cb.h>
#include <unicode/utypes.h>
diff --git a/url/url_canon_icu_unittest.cc b/url/url_canon_icu_unittest.cc
index 55fd58f..3f3025b 100644
--- a/url/url_canon_icu_unittest.cc
+++ b/url/url_canon_icu_unittest.cc
@@ -4,6 +4,7 @@
#include <stddef.h>
+#include "polyfills/base/logging.h"
#include "base/stl_util.h"
#include "testing/gtest/include/gtest/gtest.h"
#include <unicode/ucnv.h>
@@ -22,6 +23,10 @@
explicit UConvScoper(const char* charset_name) {
UErrorCode err = U_ZERO_ERROR;
converter_ = ucnv_open(charset_name, &err);
+ if (!converter_) {
+ GURL_LOG(ERROR) << "Failed to open charset " << charset_name << ": "
+ << u_errorName(err);
+ }
}
~UConvScoper() {
diff --git a/url/url_canon_internal.h b/url/url_canon_internal.h
index e0c7567..4a282b1 100644
--- a/url/url_canon_internal.h
+++ b/url/url_canon_internal.h
@@ -14,7 +14,7 @@
#include <stdlib.h>
#include "polyfills/base/component_export.h"
-#include "polyfills/base/logging.h"
+#include "polyfills/base/notreached.h"
#include "url/url_canon.h"
namespace url {
diff --git a/url/url_canon_ip.cc b/url/url_canon_ip.cc
index f7c5700..c214217 100644
--- a/url/url_canon_ip.cc
+++ b/url/url_canon_ip.cc
@@ -8,7 +8,7 @@
#include <stdlib.h>
#include <limits>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check.h"
#include "url/url_canon_internal.h"
namespace url {
diff --git a/url/url_canon_path.cc b/url/url_canon_path.cc
index ee18aa2..22002b5 100644
--- a/url/url_canon_path.cc
+++ b/url/url_canon_path.cc
@@ -4,7 +4,7 @@
#include <limits.h>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check.h"
#include "url/url_canon.h"
#include "url/url_canon_internal.h"
#include "url/url_parse_internal.h"
diff --git a/url/url_canon_relative.cc b/url/url_canon_relative.cc
index a5ec808..e148128 100644
--- a/url/url_canon_relative.cc
+++ b/url/url_canon_relative.cc
@@ -5,8 +5,9 @@
// Canonicalizer functions for working with and resolving relative URLs.
#include <algorithm>
+#include <ostream>
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check_op.h"
#include "base/strings/string_util.h"
#include "url/url_canon.h"
#include "url/url_canon_internal.h"
diff --git a/url/url_canon_unittest.cc b/url/url_canon_unittest.cc
index c3f02fb..8f709be 100644
--- a/url/url_canon_unittest.cc
+++ b/url/url_canon_unittest.cc
@@ -1517,6 +1517,10 @@
{"file:///C:/gaba?query#ref", NULL, NULL, NULL, "filer", NULL, "/foo", "b", "c", "file://filer/foo?b#c"},
// Replace nothing
{"file:///C:/gaba?query#ref", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "file:///C:/gaba?query#ref"},
+ {"file:///Y:", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "file:///Y:"},
+ {"file:///Y:/", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "file:///Y:/"},
+ {"file:///./Y", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "file:///Y"},
+ {"file:///./Y:", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "file:///Y:"},
// Clear non-path components (common)
{"file:///C:/gaba?query#ref", NULL, NULL, NULL, NULL, NULL, NULL, kDeleteComp, kDeleteComp, "file:///C:/gaba"},
// Replace path with something that doesn't begin with a slash and make
@@ -1532,6 +1536,7 @@
for (size_t i = 0; i < gurl_base::size(replace_cases); i++) {
const ReplaceCase& cur = replace_cases[i];
+ SCOPED_TRACE(cur.base);
int base_len = static_cast<int>(strlen(cur.base));
Parsed parsed;
ParseFileURL(cur.base, base_len, &parsed);
@@ -1824,13 +1829,19 @@
const char* expected;
bool expected_success;
} cases[] = {
- {"Filesystem:htTp://www.Foo.com:80/tempoRary", "filesystem:http://www.foo.com/tempoRary/", true},
- {"filesystem:httpS://www.foo.com/temporary/", "filesystem:https://www.foo.com/temporary/", true},
- {"filesystem:http://www.foo.com//", "filesystem:http://www.foo.com//", false},
- {"filesystem:http://www.foo.com/persistent/bob?query#ref", "filesystem:http://www.foo.com/persistent/bob?query#ref", true},
- {"filesystem:fIle://\\temporary/", "filesystem:file:///temporary/", true},
- {"filesystem:fiLe:///temporary", "filesystem:file:///temporary/", true},
- {"filesystem:File:///temporary/Bob?qUery#reF", "filesystem:file:///temporary/Bob?qUery#reF", true},
+ {"Filesystem:htTp://www.Foo.com:80/tempoRary",
+ "filesystem:http://www.foo.com/tempoRary/", true},
+ {"filesystem:httpS://www.foo.com/temporary/",
+ "filesystem:https://www.foo.com/temporary/", true},
+ {"filesystem:http://www.foo.com//", "filesystem:http://www.foo.com//",
+ false},
+ {"filesystem:http://www.foo.com/persistent/bob?query#ref",
+ "filesystem:http://www.foo.com/persistent/bob?query#ref", true},
+ {"filesystem:fIle://\\temporary/", "filesystem:file:///temporary/", true},
+ {"filesystem:fiLe:///temporary", "filesystem:file:///temporary/", true},
+ {"filesystem:File:///temporary/Bob?qUery#reF",
+ "filesystem:file:///temporary/Bob?qUery#reF", true},
+ {"FilEsysteM:htTp:E=/.", "filesystem:http://e%3D//", false},
};
for (size_t i = 0; i < gurl_base::size(cases); i++) {
diff --git a/url/url_idna_icu.cc b/url/url_idna_icu.cc
index b0f91a1..18e1895 100644
--- a/url/url_idna_icu.cc
+++ b/url/url_idna_icu.cc
@@ -8,7 +8,9 @@
#include <stdlib.h>
#include <string.h>
-#include "polyfills/base/logging.h"
+#include <ostream>
+
+#include "polyfills/base/check_op.h"
#include "base/no_destructor.h"
#include <unicode/uidna.h>
#include <unicode/utypes.h>
@@ -52,7 +54,7 @@
<< ". If you see this error message in a test environment "
<< "your test environment likely lacks the required data "
<< "tables for libicu. See https://crbug.com/778929.";
- value = NULL;
+ value = nullptr;
}
}
@@ -84,7 +86,7 @@
GURL_DCHECK(output->length() == 0); // Output buffer is assumed empty.
UIDNA* uidna = GetUIDNA();
- GURL_DCHECK(uidna != NULL);
+ GURL_DCHECK(uidna != nullptr);
while (true) {
UErrorCode err = U_ZERO_ERROR;
UIDNAInfo info = UIDNA_INFO_INITIALIZER;
diff --git a/url/url_parse_file.cc b/url/url_parse_file.cc
index b666d0b..c1c878a 100644
--- a/url/url_parse_file.cc
+++ b/url/url_parse_file.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "polyfills/base/logging.h"
+#include "polyfills/base/check.h"
#include "url/third_party/mozilla/url_parse.h"
#include "url/url_file.h"
#include "url/url_parse_internal.h"
diff --git a/url/url_util.cc b/url/url_util.cc
index 7c72bfc..13c30b3 100644
--- a/url/url_util.cc
+++ b/url/url_util.cc
@@ -8,8 +8,8 @@
#include <string.h>
#include <atomic>
+#include "polyfills/base/check_op.h"
#include "base/compiler_specific.h"
-#include "polyfills/base/logging.h"
#include "base/no_destructor.h"
#include "base/stl_util.h"
#include "base/strings/string_util.h"
@@ -49,6 +49,12 @@
};
// Schemes that are allowed for referrers.
+ //
+ // WARNING: Adding (1) a non-"standard" scheme or (2) a scheme whose URLs have
+ // opaque origins could lead to surprising behavior in some of the referrer
+ // generation logic. In order to avoid surprises, be sure to have adequate
+ // test coverage in each of the multiple code locations that compute
+ // referrers.
std::vector<SchemeWithType> referrer_schemes = {
{kHttpsScheme, SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION},
{kHttpScheme, SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION},
