Update googleurl to the latest version
This updates googleurl to the bfe9d19846d916ccc17fb8c5d9e1d256fc77a243
revision of upstream from Mon Mar 16 23:52:37 2020 +0000.
diff --git a/AUTHORS b/AUTHORS
index 13d16fb..a8d90ac 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -7,7 +7,10 @@
# Organization <fnmatch pattern>
#
# See python fnmatch module documentation for more information.
+#
+# Please keep the list sorted.
+# BEGIN individuals section.
Aaron Boushley <boushley@gmail.com>
Aaron Jacobs <samusaaron3@gmail.com>
Aaron Leventhal <aaronlevbugs@gmail.com>
@@ -18,9 +21,11 @@
Abhishek Agarwal <abhishek.a21@samsung.com>
Abhishek Kanike <abhishek.ka@samsung.com>
Abhishek Singh <abhi.rathore@samsung.com>
+Abul Hasan Md Osama <ahm.osama@samsung.com>
Adam Bonner <abonner-chromium@solscope.com>
Adam Bujalski <abujalski@gmail.com>
Adam Kallai <kadam@inf.u-szeged.hu>
+Adam Labuda <a.labuda@samsung.com>
Adam Roben <adam@github.com>
Adam Treat <adam.treat@samsung.com>
Adam Yi <i@adamyi.com>
@@ -41,6 +46,7 @@
Alex Scheele <alexscheele@gmail.com>
Alexander Douglas <agdoug@amazon.com>
Alexander Guettler <alexander@guettler.io>
+Alexander Rezepkin <etu@vivaldi.net>
Alexander Shalamov <alexander.shalamov@intel.com>
Alexander Sulfrian <alexander@sulfrian.net>
Alexandre Abreu <wiss1976@gmail.com>
@@ -65,6 +71,7 @@
Amruth Raj <amruthraj@motorola.com>
Amruth Raj <ckqr36@motorola.com>
Anand Ratn <anand.ratn@samsung.com>
+Anant Jain <anant90@gmail.com>
Anastasios Cassiotis <tom.cassiotis@gmail.com>
anatoly techtonik <techtonik@gmail.com>
Ancil George <ancilgeorge@samsung.com>
@@ -74,6 +81,7 @@
Andrei Parvu <parvu@adobe.com>
Andrew Boyarshin <andrew.boyarshin@gmail.com>
Andrew Brampton <me@bramp.net>
+Andrew Brindamour <abrindamour@bluejeans.com>
Andrew Hung <andrhung@amazon.com>
Andrew Jorgensen <ajorgens@amazon.com>
Andrew MacPherson <andrew.macpherson@soundtrap.com>
@@ -133,6 +141,7 @@
Branden Archer <bma4@zips.uakron.edu>
Brendan Kirby <brendan.kirby@imgtec.com>
Brendan Long <self@brendanlong.com>
+Brian Clifton <clifton@brave.com>
Brian G. Merrell <bgmerrell@gmail.com>
Brian Konzman, SJ <b.g.konzman@gmail.com>
Brian Luft <brian@electroly.com>
@@ -184,6 +193,7 @@
Clement Scheelfeldt Skau <clementskau@gmail.com>
Clinton Staley <clintstaley@gmail.com>
Connor Pearson <cjp822@gmail.com>
+Conrad Irwin <conrad.irwin@gmail.com>
Craig Schlenter <craig.schlenter@gmail.com>
Csaba Osztrogonác <ossy.szeged@gmail.com>
Daegyu Lee <na7jun8gi@gmail.com>
@@ -200,6 +210,7 @@
Daniel Lockyer <thisisdaniellockyer@gmail.com>
Daniel Nishi <dhnishi@gmail.com>
Daniel Platz <daplatz@googlemail.com>
+Daniel Playfair Cal <daniel.playfair.cal@gmail.com>
Daniel Shaulov <dshaulov@ptc.com>
Daniel Trebbien <dtrebbien@gmail.com>
Daniel Waxweiler <daniel.waxweiler@gmail.com>
@@ -213,6 +224,7 @@
David Fox <david@davidjfox.com>
David Futcher <david.mike.futcher@gmail.com>
David Leen <davileen@amazon.com>
+David Manouchehri <david@davidmanouchehri.com>
David McAllister <mcdavid@amazon.com>
David Michael Barr <david.barr@samsung.com>
David Spellman <dspell@amazon.com>
@@ -222,6 +234,7 @@
Debug Wang <debugwang@tencent.com>
Deepak Dilip Borade <deepak.db@samsung.com>
Deepak Mittal <deepak.m1@samsung.com>
+Deepak Mohan <hop2deep@gmail.com>
Deepak Sharma <deepak.sharma@amd.com>
Deepak Singla <deepak.s@samsung.com>
Deokjin Kim <deokjin81.kim@samsung.com>
@@ -273,13 +286,16 @@
Evangelos Foutras <evangelos@foutrelis.com>
Evgeniy Dushistov <dushistov@gmail.com>
Evgeny Agafonchikov <evgeny.agafonchikov@akvelon.com>
+Fabian Henneke <fabian.henneke@gmail.com>
Fabien Tassin <fta@sofaraway.org>
+Felipe Erias Morandeira <felipeerias@gmail.com>
Felix H. Dahlke <fhd@ubercode.de>
Fengrong Fang <fr.fang@samsung.com>
Fernando Jiménez Moreno <ferjmoreno@gmail.com>
Finbar Crago <finbar.crago@gmail.com>
François Beaufort <beaufort.francois@gmail.com>
Francois Kritzinger <francoisk777@gmail.com>
+Francois Marier <francois@brave.com>
Francois Rauch <leopardb@gmail.com>
Frankie Dintino <fdintino@theatlantic.com>
Franklin Ta <fta2012@gmail.com>
@@ -347,6 +363,7 @@
Huayong Xu <huayong.xu@samsung.com>
Hugo Holgersson <hugo.holgersson@sonymobile.com>
Hui Wang <wanghui07050707@gmail.com>
+Hui Wang <wanghui210@huawei.com>
Huiwon Jo <jhwon0415@gmail.com>
Huy Duong <huy.duongdinh@gmail.com>
Hwanseung Lee <hs1217.lee@gmail.com>
@@ -365,6 +382,8 @@
Ilia Demianenko <ilia.demianenko@gmail.com>
Ilia K <ki.stfu@gmail.com>
Ilya Konstantinov <ilya.konstantinov@gmail.com>
+Imam Mohammad Bokhary <imam.bokhary@samsung.com>
+Imranur Rahman <i.rahman@samsung.com>
Imranur Rahman <ir.shimul@gmail.com>
Ion Rosca <rosca@adobe.com>
Irmak Kavasoglu <irmakkavasoglu@gmail.com>
@@ -415,12 +434,16 @@
Jesse Miller <jesse@jmiller.biz>
Jesus Sanchez-Palencia <jesus.sanchez-palencia.fernandez.fil@intel.com>
Jiadong Zhu <jiadong.zhu@linaro.org>
+Jiahe Zhang <jiahe.zhang@intel.com>
Jiajia Qin <jiajia.qin@intel.com>
Jiajie Hu <jiajie.hu@intel.com>
Jianjun Zhu <jianjun.zhu@intel.com>
Jianneng Zhong <muzuiget@gmail.com>
Jiawei Shao <jiawei.shao@intel.com>
+Jiaxun Wei <leuisken@gmail.com>
+Jiaxun Yang <jiaxun.yang@flygoat.com>
Jie Chen <jie.a.chen@intel.com>
+Jihan Chao <jihan@bluejeans.com>
Jihoon Chung <j.c@navercorp.com>
Jihoon Chung <jihoon@gmail.com>
Jihun Brent Kim <devgrapher@gmail.com>
@@ -451,9 +474,11 @@
Jonathan Frazer <listedegarde@gmail.com>
Jonathan Garbee <jonathan@garbee.me>
Jonathan Hacker <jhacker@arcanefour.com>
+Jonathan Kingston <kingstonmailbox@gmail.com>
Jongdeok Kim <jongdeok.kim@navercorp.com>
Jongheon Kim <sapzape@gmail.com>
JongKwon Lee <jongkwon.lee@navercorp.com>
+Jongmok Kim <jongmok.kim@navercorp.com>
Jongsoo Lee <leejongsoo@gmail.com>
Joone Hur <joone.hur@intel.com>
Joonghun Park <pjh0718@gmail.com>
@@ -466,6 +491,7 @@
Joshua Roesslein <jroesslein@gmail.com>
Josué Ratelle <jorat1346@gmail.com>
Josyula Venkat Narasimham <venkat.nj@samsung.com>
+Joyer Huang <collger@gmail.com>
Juan Jose Lopez Jaimez <jj.lopezjaimez@gmail.com>
Juhui Lee <juhui24.lee@samsung.com>
Julien Brianceau <jbriance@cisco.com>
@@ -479,6 +505,7 @@
JungJik Lee <jungjik.lee@samsung.com>
Jungkee Song <jungkee.song@samsung.com>
Junmin Zhu <junmin.zhu@intel.com>
+Junsong Li <ljs.darkfish@gmail.com>
Justin Okamoto <justmoto@amazon.com>
Justin Ribeiro <justin@justinribeiro.com>
Jüri Valdmann <juri.valdmann@qt.io>
@@ -503,12 +530,14 @@
Kenneth Rohde Christiansen <kenneth.r.christiansen@intel.com>
Kenneth Strickland <ken.strickland@gmail.com>
Kenneth Zhou <knthzh@gmail.com>
+Kenny Levinsen <kl@kl.wtf>
Keonho Kim <keonho07.kim@samsung.com>
Ketan Goyal <ketan.goyal@samsung.com>
Kevin Gibbons <bakkot@gmail.com>
Kevin Lee Helpingstine <sig11@reprehensible.net>
Kevin M. McCormick <mckev@amazon.com>
Khasim Syed Mohammed <khasim.mohammed@linaro.org>
+Khem Raj <raj.khem@gmail.com>
Kihong Kwon <kihong.kwon@samsung.com>
Kihoon Ko <rhrlgns777@gmail.com>
Kihwang Kim <pwangkk@gmail.com>
@@ -614,6 +643,7 @@
Md Jobed Hossain <jrony15@gmail.com>
Md Sami Uddin <md.sami@samsung.com>
Michael Cirone <mikecirone@gmail.com>
+Michael Forney <mforney@mforney.org>
Michael Gilbert <floppymaster@gmail.com>
Michael Lopez <lopes92290@gmail.com>
Michael Morrison <codebythepound@gmail.com>
@@ -630,6 +660,7 @@
Mikhail Pozdnyakov <mikhail.pozdnyakov@intel.com>
Milko Leporis <milko.leporis@imgtec.com>
Milton Chiang <milton.chiang@mediatek.com>
+Milutin Smiljanic <msmiljanic.gm@gmail.com>
Minggang Wang <minggang.wang@intel.com>
Mingmin Xie <melvinxie@gmail.com>
Minjeong Lee <apenr1234@gmail.com>
@@ -679,6 +710,7 @@
Oliver Dunk <oliver@oliverdunk.com>
Olli Raula (Old name Olli Syrjälä) <olli.raula@intel.com>
Omar Sandoval <osandov@osandov.com>
+Owen Yuwono <owenyuwono@gmail.com>
Pan Deng <pan.deng@intel.com>
Parag Radke <nrqv63@motorola.com>
Paritosh Kumar <paritosh.in@samsung.com>
@@ -701,6 +733,7 @@
Pavel Ivanov <paivanof@gmail.com>
Pawel Forysiuk <p.forysiuk@samsung.com>
Paweł Hajdan jr <phajdan.jr@gmail.com>
+Piotr Zarycki <piotr.zarycki@gmail.com>
Payal Pandey <payal.pandey@samsung.com>
Peng Hu <penghu@tencent.com>
Peng Jiang <leiyi.jp@gmail.com>
@@ -735,12 +768,14 @@
Qi Yang <qi1988.yang@samsung.com>
Qiankun Miao <qiankun.miao@intel.com>
Qing Zhang <qing.zhang@intel.com>
+Qingmei Li <qingmei.li@vivo.com>
Radu Stavila <stavila@adobe.com>
Radu Velea <radu.velea@intel.com>
Rafael Antognolli <rafael.antognolli@intel.com>
Raghavendra Ghatage <r.ghatage@samsung.com>
Raghu Ram Nagaraj <r.nagaraj@samsung.com>
Rahul Gupta <rahul.g@samsung.com>
+Rajesh Mahindra <rmahindra@uber.com>
Rajneesh Rana <rajneesh.r@samsung.com>
Raman Tenneti <raman.tenneti@gmail.com>
Ramkumar Gokarnesan <ramkumar.gokarnesan@gmail.com>
@@ -824,6 +859,7 @@
Sergey Kipet <sergey.kipet@gmail.com>
Sergey Putilin <p.sergey@samsung.com>
Sergey Shekyan <shekyan@gmail.com>
+Sergey Talantov <sergey.talantov@gmail.com>
Sergio Carlos Morales Angeles <carloschilazo@gmail.com>
Sergiy Belozorov <rryk.ua@gmail.com>
Seshadri Mahalingam <seshadri.mahalingam@gmail.com>
@@ -848,6 +884,7 @@
Shirish S <shirish.s@amd.com>
Shiva Kumar <shiva.k1@samsung.com>
Shivakumar JM <shiva.jm@samsung.com>
+Shobhit Goel <shobhit.goel@samsung.com>
Shouqun Liu <liushouqun@xiaomi.com>
Shouqun Liu <shouqun.liu@intel.com>
Shreeram Kushwaha <shreeram.k@samsung.com>
@@ -857,6 +894,7 @@
Siba Samal <siba.samal@samsung.com>
Siddharth Bagai <b.siddharth@samsung.com>
Siddharth Shankar <funkysidd@gmail.com>
+Simeon Kuran <simeon.kuran@gmail.com>
Simon Arlott <simon.arlott@gmail.com>
Simon La Macchia <smacchia@amazon.com>
Siva Kumar Gunturi <siva.gunturi@samsung.com>
@@ -870,6 +908,7 @@
Sreerenj Balachandran <sreerenj.balachandran@intel.com>
Srirama Chandra Sekhar Mogali <srirama.m@samsung.com>
Staphany Park <stapark008@gmail.com>
+Stephan Hartmann <stha09@googlemail.com>
Stephen Searles <stephen.searles@gmail.com>
Steve Sanders <steve@zanderz.com>
Steven Pennington <spenn@engr.uvic.ca>
@@ -898,6 +937,7 @@
Szabolcs David <davidsz@inf.u-szeged.hu>
Szymon Piechowicz <szymonpiechowicz@o2.pl>
Taeheon Kim <skyrabbits1@gmail.com>
+Taeho Nam <thn7440@gmail.com>
Taehoon Lee <taylor.hoon@gmail.com>
Takashi Fujita <tgfjt.mail@gmail.com>
Takeshi Kurosawa <taken.spc@gmail.com>
@@ -915,6 +955,7 @@
Thomas White <im.toms.inbox@gmail.com>
Tiago Vignatti <tiago.vignatti@intel.com>
Tibor Dusnoki <tibor.dusnoki.91@gmail.com>
+Tibor Dusnoki <tdusnoki@inf.u-szeged.hu>
Tim Ansell <mithro@mithis.com>
Tim Niederhausen <tim@rnc-ag.de>
Timo Gurr <timo.gurr@gmail.com>
@@ -925,9 +966,11 @@
Tom Harwood <tfh@skip.org>
Tomas Popela <tomas.popela@gmail.com>
Torsten Kurbad <google@tk-webart.de>
+Toshihito Kikuchi <leamovret@gmail.com>
Trent Willis <trentmwillis@gmail.com>
Trevor Perrin <unsafe@trevp.net>
Tripta Gupta <tripta.g@samsung.com>
+Tuukka Toivonen <tuukka.toivonen@intel.com>
U. Artie Eoff <ullysses.a.eoff@intel.com>
Umar Hansa <umar.hansa@gmail.com>
Upendra Gowda <upendrag.gowda@gmail.com>
@@ -937,14 +980,16 @@
Valentin Ilie <valentin.ilie@intel.com>
Vamshikrishna Yellenki <vamshi@motorola.com>
Vani Hegde <vani.hegde@samsung.com>
-Varun Chowdhary Paturi <v.paturi@samsung.com>
Vartul Katiyar <vartul.k@samsung.com>
+Varun Chowdhary Paturi <v.paturi@samsung.com>
+Varun Varada <varuncvarada@gmail.com>
Vedran Šajatović <vedran.sajatovic@gmail.com>
Vernon Tang <vt@foilhead.net>
Viatcheslav Ostapenko <sl.ostapenko@samsung.com>
Victor Costan <costan@gmail.com>
Viet-Trung Luu <viettrungluu@gmail.com>
Vinay Anantharaman <vinaya@adobe.com>
+Vinoth Chandar <vinoth@uber.com>
Vipul Bhasin <vipul.bhasin@gmail.com>
Visa Putkinen <v.putkinen@partner.samsung.com>
Vishal Bhatnagar <vishal.b@samsung.com>
@@ -954,8 +999,10 @@
Waihung Fu <fufranci@amazon.com>
Wanming Lin <wanming.lin@intel.com>
Wei Li <wei.c.li@intel.com>
+Wenxiang Qian <leonwxqian@gmail.com>
WenSheng He <wensheng.he@samsung.com>
Wesley Lancel <wesleylancel@gmail.com>
+Wei Wang <wei4.wang@intel.com>
Wesley Wigham <wwigham@gmail.com>
Will Hirsch <chromium@willhirsch.co.uk>
Will Shackleton <w.shackleton@gmail.com>
@@ -979,7 +1026,7 @@
Yael Aharon <yael.aharon@intel.com>
Yan Wang <yan0422.wang@samsung.com>
Yang Gu <yang.gu@intel.com>
-Yannic Bonenberger <contact@yannic-bonenberger.com>
+Yannic Bonenberger <yannic.bonenberger@gmail.com>
Yarin Kaul <yarin.kaul@gmail.com>
Yash Vempati <vempatiy@amazon.com>
Ye Liu <cbakgly@gmail.com>
@@ -1005,7 +1052,9 @@
Youngmin Yoo <youngmin.yoo@samsung.com>
Youngsoo Choi <kenshin.choi@samsung.com>
Youngsun Suh <zard17@gmail.com>
+Yuan-Pin Yu <yjames@uber.com>
Yuhong Sha <yuhong.sha@samsung.com>
+Yuki Tsuchiya <Yuki.Tsuchiya@sony.com>
Yumikiyo Osanai <yumios.art@gmail.com>
Yunchao He <yunchao.he@intel.com>
Yupei Lin <yplam@yplam.com>
@@ -1013,12 +1062,14 @@
Yura Yaroshevich <yura.yaroshevich@gmail.com>
Yuri Gorobets <yuri.gorobets@gmail.com>
Yuriy Taraday <yorik.sar@gmail.com>
+Yuta Kasai <kasai.yuta0810@gmail.com>
Yuvanesh Natarajan <yuvanesh.n1@samsung.com>
Zeno Albisser <zeno.albisser@digia.com>
Zeqin Chen <talonchen@tencent.com>
Zhaoze Zhou <zhaoze.zhou@partner.samsung.com>
Zheda Chen <zheda.chen@intel.com>
Zheng Chuang <zhengchuangscu@gmail.com>
+Zheng Xu <zxu@kobo.com>
Zhengkun Li <zhengkli@amazon.com>
Zhenyu Liang <zhenyu.liang@intel.com>
Zhenyu Shan <zhenyu.shan@intel.com>
@@ -1029,12 +1080,9 @@
Zoltan Kuscsik <zoltan.kuscsik@linaro.org>
Zsolt Borbely <zsborbely.u-szeged@partner.samsung.com>
方觉 (Fang Jue) <fangjue23303@gmail.com>
-Rajesh Mahindra <rmahindra@uber.com>
-Yuan-Pin Yu <yjames@uber.com>
-Vinoth Chandar <vinoth@uber.com>
-Zheng Xu <zxu@kobo.com>
-Junsong Li <ljs.darkfish@gmail.com>
+# END individuals section.
+# BEGIN organizations section.
ACCESS CO., LTD. <*@access-company.com>
Akamai Inc. <*@akamai.com>
ARM Holdings <*@arm.com>
@@ -1042,10 +1090,12 @@
Bocoup <*@bocoup.com>
Canonical Limited <*@canonical.com>
Cloudflare, Inc. <*@cloudflare.com>
+CloudMosa, Inc. <*@cloudmosa.com>
Code Aurora Forum <*@codeaurora.org>
Collabora Limited <*@collabora.com>
Comodo CA Limited
Cosium <*@cosium.com>
+Dell Technologies Inc. <*@dell.corp-partner.google.com>
Duck Duck Go, Inc. <*@duckduckgo.com>
Endless Mobile, Inc. <*@endlessm.com>
Estimote, Inc. <*@estimote.com>
@@ -1062,6 +1112,8 @@
LG Electronics, Inc. <*@lge.com>
Loongson Technology Corporation Limited. <*@loongson.cn>
Macadamian <*@macadamian.com>
+Mail.ru Group <*@corp.mail.ru>
+Make Positive Provar Limited <*@provartesting.com>
Mediatek <*@mediatek.com>
Microsoft <*@microsoft.com>
MIPS Technologies, Inc. <*@mips.com>
@@ -1087,4 +1139,4 @@
Vewd Software AS <*@vewd.com>
Vivaldi Technologies AS <*@vivaldi.com>
Yandex LLC <*@yandex-team.ru>
-Make Positive Provar Limited <*@provartesting.com>
+# END organizations section.
diff --git a/base/compiler_specific.h b/base/compiler_specific.h
index 7e2c510..2962537 100644
--- a/base/compiler_specific.h
+++ b/base/compiler_specific.h
@@ -7,58 +7,10 @@
#include "build/build_config.h"
-#if defined(COMPILER_MSVC)
-
-#if !defined(__clang__)
+#if defined(COMPILER_MSVC) && !defined(__clang__)
#error "Only clang-cl is supported on Windows, see https://crbug.com/988071"
#endif
-// Macros for suppressing and disabling warnings on MSVC.
-//
-// Warning numbers are enumerated at:
-// http://msdn.microsoft.com/en-us/library/8x5x43k7(VS.80).aspx
-//
-// The warning pragma:
-// http://msdn.microsoft.com/en-us/library/2c8f766e(VS.80).aspx
-//
-// Using __pragma instead of #pragma inside macros:
-// http://msdn.microsoft.com/en-us/library/d9x1s805.aspx
-
-// MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled.
-// The warning remains disabled until popped by MSVC_POP_WARNING.
-#define MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \
- __pragma(warning(disable:n))
-
-// Pop effects of innermost MSVC_PUSH_* macro.
-#define MSVC_POP_WARNING() __pragma(warning(pop))
-
-#else // Not MSVC
-
-#define MSVC_PUSH_DISABLE_WARNING(n)
-#define MSVC_POP_WARNING()
-#define MSVC_DISABLE_OPTIMIZE()
-#define MSVC_ENABLE_OPTIMIZE()
-
-#endif // COMPILER_MSVC
-
-// These macros can be helpful when investigating compiler bugs or when
-// investigating issues in local optimized builds, by temporarily disabling
-// optimizations for a single function or file. These macros should never be
-// used to permanently work around compiler bugs or other mysteries, and should
-// not be used in landed changes.
-#if !defined(OFFICIAL_BUILD)
-#if defined(__clang__)
-#define DISABLE_OPTIMIZE() __pragma(clang optimize off)
-#define ENABLE_OPTIMIZE() __pragma(clang optimize on)
-#elif defined(COMPILER_MSVC)
-#define DISABLE_OPTIMIZE() __pragma(optimize("", off))
-#define ENABLE_OPTIMIZE() __pragma(optimize("", on))
-#else
-// These macros are not currently available for other compiler options.
-#endif
-// These macros are not available in official builds.
-#endif // !defined(OFFICIAL_BUILD)
-
// Annotate a variable indicating it's ok if the variable is not used.
// (Typically used to silence a compiler warning when the assignment
// is important for some other reason.)
@@ -141,7 +93,7 @@
// For member functions, the implicit this parameter counts as index 1.
#if defined(COMPILER_GCC) || defined(__clang__)
#define PRINTF_FORMAT(format_param, dots_param) \
- __attribute__((format(printf, format_param, dots_param)))
+ __attribute__((format(printf, format_param, dots_param)))
#else
#define PRINTF_FORMAT(format_param, dots_param)
#endif
@@ -170,14 +122,14 @@
// Mark a memory region fully initialized.
// Use this to annotate code that deliberately reads uninitialized data, for
// example a GC scavenging root set pointers from the stack.
-#define MSAN_UNPOISON(p, size) __msan_unpoison(p, size)
+#define MSAN_UNPOISON(p, size) __msan_unpoison(p, size)
// Check a memory region for initializedness, as if it was being used here.
// If any bits are uninitialized, crash with an MSan report.
// Use this to sanitize data which MSan won't be able to track, e.g. before
// passing data to another process via shared memory.
#define MSAN_CHECK_MEM_IS_INITIALIZED(p, size) \
- __msan_check_mem_is_initialized(p, size)
+ __msan_check_mem_is_initialized(p, size)
#else // MEMORY_SANITIZER
#define MSAN_UNPOISON(p, size)
#define MSAN_CHECK_MEM_IS_INITIALIZED(p, size)
@@ -260,4 +212,39 @@
#endif
#endif
+#if defined(__clang__) && __has_attribute(uninitialized)
+// Attribute "uninitialized" disables -ftrivial-auto-var-init=pattern for
+// the specified variable.
+// Library-wide alternative is
+// 'configs -= [ "//build/config/compiler:default_init_stack_vars" ]' in .gn
+// file.
+//
+// See "init_stack_vars" in build/config/compiler/BUILD.gn and
+// http://crbug.com/977230
+// "init_stack_vars" is enabled for non-official builds and we hope to enable it
+// in official build in 2020 as well. The flag writes fixed pattern into
+// uninitialized parts of all local variables. In rare cases such initialization
+// is undesirable and attribute can be used:
+// 1. Degraded performance
+// In most cases compiler is able to remove additional stores. E.g. if memory is
+// never accessed or properly initialized later. Preserved stores mostly will
+// not affect program performance. However if compiler failed on some
+// performance critical code we can get a visible regression in a benchmark.
+// 2. memset, memcpy calls
+// Compiler may replaces some memory writes with memset or memcpy calls. This is
+// not -ftrivial-auto-var-init specific, but it can happen more likely with the
+// flag. It can be a problem if code is not linked with C run-time library.
+//
+// Note: The flag is security risk mitigation feature. So in future the
+// attribute uses should be avoided when possible. However to enable this
+// mitigation on the most of the code we need to be less strict now and minimize
+// number of exceptions later. So if in doubt feel free to use attribute, but
+// please document the problem for someone who is going to cleanup it later.
+// E.g. platform, bot, benchmark or test name in patch description or next to
+// the attribute.
+#define STACK_UNINITIALIZED __attribute__((uninitialized))
+#else
+#define STACK_UNINITIALIZED
+#endif
+
#endif // BASE_COMPILER_SPECIFIC_H_
diff --git a/base/macros.h b/base/macros.h
index cda8e3a..c67bdbd 100644
--- a/base/macros.h
+++ b/base/macros.h
@@ -10,6 +10,10 @@
#ifndef BASE_MACROS_H_
#define BASE_MACROS_H_
+// ALL DISALLOW_xxx MACROS ARE DEPRECATED; DO NOT USE IN NEW CODE.
+// Use explicit deletions instead. See the section on copyability/movability in
+// //styleguide/c++/c++-dos-and-donts.md for more information.
+
// Put this in the declarations for a class to be uncopyable.
#define DISALLOW_COPY(TypeName) \
TypeName(const TypeName&) = delete
diff --git a/base/optional.h b/base/optional.h
index 345147c..a043122 100644
--- a/base/optional.h
+++ b/base/optional.h
@@ -30,11 +30,13 @@
namespace internal {
+struct DummyUnionMember {};
+
template <typename T, bool = std::is_trivially_destructible<T>::value>
struct OptionalStorageBase {
- // Initializing |empty_| here instead of using default member initializing
- // to avoid errors in g++ 4.8.
- constexpr OptionalStorageBase() : empty_('\0') {}
+ // Provide non-defaulted default ctor to make sure it's not deleted by
+ // non-trivial T::T() in the union.
+ constexpr OptionalStorageBase() : dummy_() {}
template <class... Args>
constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
@@ -65,19 +67,28 @@
bool is_populated_ = false;
union {
- // |empty_| exists so that the union will always be initialized, even when
+ // |dummy_| exists so that the union will always be initialized, even when
// it doesn't contain a value. Union members must be initialized for the
- // constructor to be 'constexpr'.
- char empty_;
+ // constructor to be 'constexpr'. Having a special trivial class for it is
+ // better than e.g. using char, because the latter will have to be
+ // zero-initialized, and the compiler can't optimize this write away, since
+ // it assumes this might be a programmer's invariant. This can also cause
+ // problems for conservative GC in Oilpan. Compiler is free to split shared
+ // and non-shared parts of the union in separate memory locations (or
+ // registers). If conservative GC is triggered at this moment, the stack
+ // scanning routine won't find the correct object pointed from
+ // Optional<HeapObject*>. This dummy valueless struct lets the compiler know
+ // that we don't care about the value of this union member.
+ DummyUnionMember dummy_;
T value_;
};
};
template <typename T>
struct OptionalStorageBase<T, true /* trivially destructible */> {
- // Initializing |empty_| here instead of using default member initializing
- // to avoid errors in g++ 4.8.
- constexpr OptionalStorageBase() : empty_('\0') {}
+ // Provide non-defaulted default ctor to make sure it's not deleted by
+ // non-trivial T::T() in the union.
+ constexpr OptionalStorageBase() : dummy_() {}
template <class... Args>
constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
@@ -106,10 +117,19 @@
bool is_populated_ = false;
union {
- // |empty_| exists so that the union will always be initialized, even when
+ // |dummy_| exists so that the union will always be initialized, even when
// it doesn't contain a value. Union members must be initialized for the
- // constructor to be 'constexpr'.
- char empty_;
+ // constructor to be 'constexpr'. Having a special trivial class for it is
+ // better than e.g. using char, because the latter will have to be
+ // zero-initialized, and the compiler can't optimize this write away, since
+ // it assumes this might be a programmer's invariant. This can also cause
+ // problems for conservative GC in Oilpan. Compiler is free to split shared
+ // and non-shared parts of the union in separate memory locations (or
+ // registers). If conservative GC is triggered at this moment, the stack
+ // scanning routine won't find the correct object pointed from
+ // Optional<HeapObject*>. This dummy valueless struct lets the compiler know
+ // that we don't care about the value of this union member.
+ DummyUnionMember dummy_;
T value_;
};
};
diff --git a/base/stl_util.h b/base/stl_util.h
index d6ca464..7fc8108 100644
--- a/base/stl_util.h
+++ b/base/stl_util.h
@@ -31,15 +31,18 @@
namespace internal {
-// Calls erase on iterators of matching elements.
+// Calls erase on iterators of matching elements and returns the number of
+// removed elements.
template <typename Container, typename Predicate>
-void IterateAndEraseIf(Container& container, Predicate pred) {
- for (auto it = container.begin(); it != container.end();) {
+size_t IterateAndEraseIf(Container& container, Predicate pred) {
+ size_t old_size = container.size();
+ for (auto it = container.begin(), last = container.end(); it != last;) {
if (pred(*it))
it = container.erase(it);
else
++it;
}
+ return old_size - container.size();
}
template <typename Iter>
@@ -144,6 +147,30 @@
return il.begin();
}
+// std::array::data() was not constexpr prior to C++17 [1].
+// Hence these overloads are provided.
+//
+// [1] https://en.cppreference.com/w/cpp/container/array/data
+template <typename T, size_t N>
+constexpr T* data(std::array<T, N>& array) noexcept {
+ return !array.empty() ? &array[0] : nullptr;
+}
+
+template <typename T, size_t N>
+constexpr const T* data(const std::array<T, N>& array) noexcept {
+ return !array.empty() ? &array[0] : nullptr;
+}
+
+// C++14 implementation of C++17's std::as_const():
+// https://en.cppreference.com/w/cpp/utility/as_const
+template <typename T>
+constexpr std::add_const_t<T>& as_const(T& t) noexcept {
+ return t;
+}
+
+template <typename T>
+void as_const(const T&& t) = delete;
+
// Returns a const reference to the underlying container of a container adapter.
// Works for std::priority_queue, std::queue, and std::stack.
template <class A>
@@ -473,8 +500,9 @@
a2.begin(), a2.end());
}
-// Erase/EraseIf are based on library fundamentals ts v2 erase/erase_if
-// http://en.cppreference.com/w/cpp/experimental/lib_extensions_2
+// Erase/EraseIf are based on C++20's uniform container erasure API:
+// - https://eel.is/c++draft/libraryindex#:erase
+// - https://eel.is/c++draft/libraryindex#:erase_if
// They provide a generic way to erase elements from a container.
// The functions here implement these for the standard containers until those
// functions are available in the C++ standard.
@@ -484,89 +512,109 @@
// have it either.
template <typename CharT, typename Traits, typename Allocator, typename Value>
-void Erase(std::basic_string<CharT, Traits, Allocator>& container,
- const Value& value) {
- container.erase(std::remove(container.begin(), container.end(), value),
- container.end());
+size_t Erase(std::basic_string<CharT, Traits, Allocator>& container,
+ const Value& value) {
+ auto it = std::remove(container.begin(), container.end(), value);
+ size_t removed = std::distance(it, container.end());
+ container.erase(it, container.end());
+ return removed;
}
template <typename CharT, typename Traits, typename Allocator, class Predicate>
-void EraseIf(std::basic_string<CharT, Traits, Allocator>& container,
- Predicate pred) {
- container.erase(std::remove_if(container.begin(), container.end(), pred),
- container.end());
+size_t EraseIf(std::basic_string<CharT, Traits, Allocator>& container,
+ Predicate pred) {
+ auto it = std::remove_if(container.begin(), container.end(), pred);
+ size_t removed = std::distance(it, container.end());
+ container.erase(it, container.end());
+ return removed;
}
template <class T, class Allocator, class Value>
-void Erase(std::deque<T, Allocator>& container, const Value& value) {
- container.erase(std::remove(container.begin(), container.end(), value),
- container.end());
+size_t Erase(std::deque<T, Allocator>& container, const Value& value) {
+ auto it = std::remove(container.begin(), container.end(), value);
+ size_t removed = std::distance(it, container.end());
+ container.erase(it, container.end());
+ return removed;
}
template <class T, class Allocator, class Predicate>
-void EraseIf(std::deque<T, Allocator>& container, Predicate pred) {
- container.erase(std::remove_if(container.begin(), container.end(), pred),
- container.end());
+size_t EraseIf(std::deque<T, Allocator>& container, Predicate pred) {
+ auto it = std::remove_if(container.begin(), container.end(), pred);
+ size_t removed = std::distance(it, container.end());
+ container.erase(it, container.end());
+ return removed;
}
template <class T, class Allocator, class Value>
-void Erase(std::vector<T, Allocator>& container, const Value& value) {
- container.erase(std::remove(container.begin(), container.end(), value),
- container.end());
+size_t Erase(std::vector<T, Allocator>& container, const Value& value) {
+ auto it = std::remove(container.begin(), container.end(), value);
+ size_t removed = std::distance(it, container.end());
+ container.erase(it, container.end());
+ return removed;
}
template <class T, class Allocator, class Predicate>
-void EraseIf(std::vector<T, Allocator>& container, Predicate pred) {
- container.erase(std::remove_if(container.begin(), container.end(), pred),
- container.end());
+size_t EraseIf(std::vector<T, Allocator>& container, Predicate pred) {
+ auto it = std::remove_if(container.begin(), container.end(), pred);
+ size_t removed = std::distance(it, container.end());
+ container.erase(it, container.end());
+ return removed;
}
template <class T, class Allocator, class Value>
-void Erase(std::forward_list<T, Allocator>& container, const Value& 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.
- container.remove_if([&](const T& cur) { return cur == value; });
+ return EraseIf(container, [&](const T& cur) { return cur == value; });
}
template <class T, class Allocator, class Predicate>
-void EraseIf(std::forward_list<T, Allocator>& container, Predicate pred) {
+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
+ // O(n) std::distance work-around. However, given that EraseIf is O(n)
+ // already, this should not make a big difference.
+ size_t old_size = std::distance(container.begin(), container.end());
container.remove_if(pred);
+ return old_size - std::distance(container.begin(), container.end());
}
template <class T, class Allocator, class Value>
-void Erase(std::list<T, Allocator>& container, const Value& 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.
- container.remove_if([&](const T& cur) { return cur == value; });
+ return EraseIf(container, [&](const T& cur) { return cur == value; });
}
template <class T, class Allocator, class Predicate>
-void EraseIf(std::list<T, Allocator>& container, Predicate pred) {
+size_t EraseIf(std::list<T, Allocator>& container, Predicate pred) {
+ size_t old_size = container.size();
container.remove_if(pred);
+ return old_size - container.size();
}
template <class Key, class T, class Compare, class Allocator, class Predicate>
-void EraseIf(std::map<Key, T, Compare, Allocator>& container, Predicate pred) {
- internal::IterateAndEraseIf(container, pred);
+size_t EraseIf(std::map<Key, T, Compare, Allocator>& container,
+ Predicate pred) {
+ return internal::IterateAndEraseIf(container, pred);
}
template <class Key, class T, class Compare, class Allocator, class Predicate>
-void EraseIf(std::multimap<Key, T, Compare, Allocator>& container,
- Predicate pred) {
- internal::IterateAndEraseIf(container, pred);
+size_t EraseIf(std::multimap<Key, T, Compare, Allocator>& container,
+ Predicate pred) {
+ return internal::IterateAndEraseIf(container, pred);
}
template <class Key, class Compare, class Allocator, class Predicate>
-void EraseIf(std::set<Key, Compare, Allocator>& container, Predicate pred) {
- internal::IterateAndEraseIf(container, pred);
+size_t EraseIf(std::set<Key, Compare, Allocator>& container, Predicate pred) {
+ return internal::IterateAndEraseIf(container, pred);
}
template <class Key, class Compare, class Allocator, class Predicate>
-void EraseIf(std::multiset<Key, Compare, Allocator>& container,
- Predicate pred) {
- internal::IterateAndEraseIf(container, pred);
+size_t EraseIf(std::multiset<Key, Compare, Allocator>& container,
+ Predicate pred) {
+ return internal::IterateAndEraseIf(container, pred);
}
template <class Key,
@@ -575,9 +623,9 @@
class KeyEqual,
class Allocator,
class Predicate>
-void EraseIf(std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& container,
- Predicate pred) {
- internal::IterateAndEraseIf(container, pred);
+size_t EraseIf(std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& container,
+ Predicate pred) {
+ return internal::IterateAndEraseIf(container, pred);
}
template <class Key,
@@ -586,10 +634,10 @@
class KeyEqual,
class Allocator,
class Predicate>
-void EraseIf(
+size_t EraseIf(
std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>& container,
Predicate pred) {
- internal::IterateAndEraseIf(container, pred);
+ return internal::IterateAndEraseIf(container, pred);
}
template <class Key,
@@ -597,9 +645,9 @@
class KeyEqual,
class Allocator,
class Predicate>
-void EraseIf(std::unordered_set<Key, Hash, KeyEqual, Allocator>& container,
- Predicate pred) {
- internal::IterateAndEraseIf(container, pred);
+size_t EraseIf(std::unordered_set<Key, Hash, KeyEqual, Allocator>& container,
+ Predicate pred) {
+ return internal::IterateAndEraseIf(container, pred);
}
template <class Key,
@@ -607,9 +655,10 @@
class KeyEqual,
class Allocator,
class Predicate>
-void EraseIf(std::unordered_multiset<Key, Hash, KeyEqual, Allocator>& container,
- Predicate pred) {
- internal::IterateAndEraseIf(container, pred);
+size_t EraseIf(
+ std::unordered_multiset<Key, Hash, KeyEqual, Allocator>& container,
+ Predicate pred) {
+ return internal::IterateAndEraseIf(container, pred);
}
// A helper class to be used as the predicate with |EraseIf| to implement
diff --git a/base/strings/strcat.cc b/base/strings/strcat.cc
index 1774a15..db41a69 100644
--- a/base/strings/strcat.cc
+++ b/base/strings/strcat.cc
@@ -8,8 +8,8 @@
namespace {
-// Reserves an additional amount of size in the given string, growing by at
-// least 2x. Used by StrAppend().
+// 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
@@ -18,11 +18,15 @@
// 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().
-//
-// If the string is empty, we assume that exponential growth is not necessary.
template <typename String>
-void ReserveAdditional(String* str, typename String::size_type additional) {
- str->reserve(std::max(str->size() + additional, str->size() * 2));
+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>
@@ -30,7 +34,7 @@
size_t additional_size = 0;
for (const auto& cur : pieces)
additional_size += cur.size();
- ReserveAdditional(dest, additional_size);
+ ReserveAdditionalIfNeeded(dest, additional_size);
for (const auto& cur : pieces)
dest->append(cur.data(), cur.size());
diff --git a/base/strings/strcat.h b/base/strings/strcat.h
index bcdfe17..220fa24 100644
--- a/base/strings/strcat.h
+++ b/base/strings/strcat.h
@@ -59,10 +59,13 @@
// for this call and generate slightly less code. This is something we can
// explore more in the future.
-BASE_EXPORT std::string StrCat(span<const StringPiece> pieces);
-BASE_EXPORT string16 StrCat(span<const StringPiece16> pieces);
-BASE_EXPORT std::string StrCat(span<const std::string> pieces);
-BASE_EXPORT string16 StrCat(span<const string16> pieces);
+BASE_EXPORT std::string StrCat(span<const StringPiece> pieces)
+ WARN_UNUSED_RESULT;
+BASE_EXPORT string16 StrCat(span<const StringPiece16> pieces)
+ WARN_UNUSED_RESULT;
+BASE_EXPORT std::string StrCat(span<const std::string> pieces)
+ WARN_UNUSED_RESULT;
+BASE_EXPORT string16 StrCat(span<const string16> pieces) WARN_UNUSED_RESULT;
// Initializer list forwards to the array version.
inline std::string StrCat(std::initializer_list<StringPiece> pieces) {
diff --git a/base/strings/strcat_unittest.cc b/base/strings/strcat_unittest.cc
index d51b840..9374c39 100644
--- a/base/strings/strcat_unittest.cc
+++ b/base/strings/strcat_unittest.cc
@@ -64,4 +64,22 @@
EXPECT_EQ(ASCIIToUTF16("foo122333"), result);
}
+TEST(StrAppendT, ReserveAdditionalIfNeeded) {
+ std::string str = "foo";
+ const char* prev_data = str.data();
+ size_t prev_capacity = str.capacity();
+ // Fully exhaust current capacity.
+ StrAppend(&str, {std::string(str.capacity() - str.size(), 'o')});
+ // Expect that we hit capacity, but didn't require a re-alloc.
+ EXPECT_EQ(str.capacity(), str.size());
+ EXPECT_EQ(prev_data, str.data());
+ EXPECT_EQ(prev_capacity, str.capacity());
+
+ // Force a re-alloc by appending another character.
+ StrAppend(&str, {"o"});
+
+ // Expect at least 2x growth in capacity.
+ EXPECT_LE(2 * prev_capacity, str.capacity());
+}
+
} // namespace base
diff --git a/base/strings/string_number_conversions.cc b/base/strings/string_number_conversions.cc
index 2bf6142..701d71c 100644
--- a/base/strings/string_number_conversions.cc
+++ b/base/strings/string_number_conversions.cc
@@ -13,10 +13,11 @@
#include <type_traits>
#include "polyfills/base/logging.h"
+#include "base/no_destructor.h"
#include "base/numerics/safe_math.h"
-#include "base/scoped_clear_last_error.h"
+#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
-#include "base/third_party/dmg_fp/dmg_fp.h"
+#include "base/third_party/double_conversion/double-conversion/double-conversion.h"
namespace gurl_base {
@@ -360,21 +361,29 @@
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();
+}
+
std::string NumberToString(double value) {
- // According to g_fmt.cc, it is sufficient to declare a buffer of size 32.
char buffer[32];
- dmg_fp::g_fmt(buffer, value);
- return std::string(buffer);
+ double_conversion::StringBuilder builder(buffer, sizeof(buffer));
+ GetDoubleToStringConverter()->ToShortest(value, &builder);
+ return std::string(buffer, builder.position());
}
gurl_base::string16 NumberToString16(double value) {
- // According to g_fmt.cc, it is sufficient to declare a buffer of size 32.
char buffer[32];
- dmg_fp::g_fmt(buffer, value);
+ 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[strlen(buffer)]);
+ return gurl_base::string16(&buffer[0], &buffer[builder.position()]);
}
bool StringToInt(StringPiece input, int* output) {
@@ -417,35 +426,37 @@
return String16ToIntImpl(input, output);
}
-bool StringToDouble(const std::string& input, double* output) {
- // Thread-safe? It is on at least Mac, Linux, and Windows.
- internal::ScopedClearLastError clear_errno;
+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);
- char* endptr = nullptr;
- *output = dmg_fp::strtod(input.c_str(), &endptr);
+ int processed_characters_count;
+ *output = converter->StringToDouble(data, input.size(),
+ &processed_characters_count);
// Cases to return false:
- // - If errno is ERANGE, there was an overflow or underflow.
// - If the input string is empty, there was nothing to parse.
- // - If endptr does not point to the end of the string, there are either
- // characters remaining in the string after a parsed number, or the string
- // does not begin with a parseable number. endptr is compared to the
- // expected end given the string's stated length to correctly catch cases
- // where the string contains embedded NUL characters.
+ // - 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 errno == 0 &&
- !input.empty() &&
- input.c_str() + input.length() == endptr &&
- !isspace(input[0]);
+ return !input.empty() && *output != HUGE_VAL && *output != -HUGE_VAL &&
+ static_cast<size_t>(processed_characters_count) == input.size() &&
+ !IsUnicodeWhitespace(input[0]);
}
-// Note: if you need to add String16ToDouble, first ask yourself if it's
-// really necessary. If it is, probably the best implementation here is to
-// convert to 8-bit and then use the 8-bit version.
+bool StringToDouble(StringPiece input, double* output) {
+ return StringToDoubleImpl(input, input.data(), output);
+}
-// Note: if you need to add an iterator range version of StringToDouble, first
-// ask yourself if it's really necessary. If it is, probably the best
-// implementation here is to instantiate a string and use the string version.
+bool StringToDouble(StringPiece16 input, double* output) {
+ return StringToDoubleImpl(
+ input, reinterpret_cast<const uint16_t*>(input.data()), output);
+}
std::string HexEncode(const void* bytes, size_t size) {
static const char kHexChars[] = "0123456789ABCDEF";
@@ -485,7 +496,8 @@
input.begin(), input.end(), output);
}
-bool HexStringToBytes(StringPiece input, std::vector<uint8_t>* 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)
@@ -502,4 +514,32 @@
return true;
}
+bool HexStringToBytes(StringPiece input, std::vector<uint8_t>* output) {
+ return HexStringToByteContainer(input, output);
+}
+
+bool HexStringToString(StringPiece input, std::string* output) {
+ return HexStringToByteContainer(input, output);
+}
+
+bool HexStringToSpan(StringPiece input, gurl_base::span<uint8_t> output) {
+ size_t count = input.size();
+ if (count == 0 || (count % 2) != 0)
+ 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;
+}
+
} // namespace base
diff --git a/base/strings/string_number_conversions.h b/base/strings/string_number_conversions.h
index a3acab8..872ead2 100644
--- a/base/strings/string_number_conversions.h
+++ b/base/strings/string_number_conversions.h
@@ -98,7 +98,8 @@
// If your input is locale specific, use ICU to read the number.
// WARNING: Will write to |output| even when returning false.
// Read the comments here and above StringToInt() carefully.
-BASE_EXPORT bool StringToDouble(const std::string& input, double* output);
+BASE_EXPORT bool StringToDouble(StringPiece input, double* output);
+BASE_EXPORT bool StringToDouble(StringPiece16 input, double* output);
// Hex encoding ----------------------------------------------------------------
@@ -140,6 +141,17 @@
BASE_EXPORT bool HexStringToBytes(StringPiece input,
std::vector<uint8_t>* output);
+// Same as HexStringToBytes, but for an std::string.
+BASE_EXPORT bool HexStringToString(StringPiece input, std::string* output);
+
+// Decodes the hex string |input| into a presized |output|. The output buffer
+// must be sized exactly to |input.size() / 2| or decoding will fail and no
+// bytes will be written to |output|. Decoding an empty input is also
+// considered a failure. When decoding fails due to encountering invalid input
+// characters, |output| will have been filled with the decoded bytes up until
+// the failure.
+BASE_EXPORT bool HexStringToSpan(StringPiece input, gurl_base::span<uint8_t> output);
+
} // namespace base
#endif // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
diff --git a/base/strings/string_number_conversions_unittest.cc b/base/strings/string_number_conversions_unittest.cc
index 93405e2..6f8d171 100644
--- a/base/strings/string_number_conversions_unittest.cc
+++ b/base/strings/string_number_conversions_unittest.cc
@@ -672,7 +672,8 @@
EXPECT_EQ(0xc0ffeeU, output);
}
-TEST(StringNumberConversionsTest, HexStringToBytes) {
+// Tests for HexStringToBytes, HexStringToString, HexStringToSpan.
+TEST(StringNumberConversionsTest, HexStringToBytesStringSpan) {
static const struct {
const std::string input;
const char* output;
@@ -698,16 +699,65 @@
"\x01\x23\x45\x67\x89\xAB\xCD\xEF\x01\x23\x45", 11, true},
};
- for (size_t i = 0; i < gurl_base::size(cases); ++i) {
- std::vector<uint8_t> output;
- std::vector<uint8_t> compare;
- EXPECT_EQ(cases[i].success, HexStringToBytes(cases[i].input, &output)) <<
- i << ": " << cases[i].input;
- for (size_t j = 0; j < cases[i].output_len; ++j)
- compare.push_back(static_cast<uint8_t>(cases[i].output[j]));
- ASSERT_EQ(output.size(), compare.size()) << i << ": " << cases[i].input;
- EXPECT_TRUE(std::equal(output.begin(), output.end(), compare.begin())) <<
- i << ": " << cases[i].input;
+ for (size_t test_i = 0; test_i < gurl_base::size(cases); ++test_i) {
+ const auto& test = cases[test_i];
+
+ std::string expected_output(test.output, test.output_len);
+
+ // Test HexStringToBytes().
+ {
+ std::vector<uint8_t> output;
+ EXPECT_EQ(test.success, HexStringToBytes(test.input, &output))
+ << test_i << ": " << test.input;
+ EXPECT_EQ(expected_output, std::string(output.begin(), output.end()));
+ }
+
+ // Test HexStringToString().
+ {
+ std::string output;
+ EXPECT_EQ(test.success, HexStringToString(test.input, &output))
+ << test_i << ": " << test.input;
+ EXPECT_EQ(expected_output, output) << test_i << ": " << test.input;
+ }
+
+ // Test HexStringToSpan() with a properly sized output.
+ {
+ std::vector<uint8_t> output;
+ output.resize(test.input.size() / 2);
+
+ EXPECT_EQ(test.success, HexStringToSpan(test.input, output))
+ << test_i << ": " << test.input;
+
+ // On failure the output will only have been partially written (with
+ // everything after the failure being 0).
+ for (size_t i = 0; i < test.output_len; ++i) {
+ EXPECT_EQ(test.output[i], static_cast<char>(output[i]))
+ << test_i << ": " << test.input;
+ }
+ for (size_t i = test.output_len; i < output.size(); ++i) {
+ EXPECT_EQ('\0', static_cast<char>(output[i]))
+ << test_i << ": " << test.input;
+ }
+ }
+
+ // Test HexStringToSpan() with an output that is 1 byte too small.
+ {
+ std::vector<uint8_t> output;
+ if (test.input.size() > 1)
+ output.resize(test.input.size() / 2 - 1);
+
+ EXPECT_FALSE(HexStringToSpan(test.input, output))
+ << test_i << ": " << test.input;
+ }
+
+ // Test HexStringToSpan() with an output that is 1 byte too large.
+ {
+ std::vector<uint8_t> output;
+ output.resize(test.input.size() / 2 + 1);
+
+ EXPECT_FALSE(HexStringToSpan(test.input, output))
+ << test_i << ": " << test.input;
+ }
}
}
@@ -791,6 +841,8 @@
};
for (size_t i = 0; i < gurl_base::size(cases); ++i) {
+ SCOPED_TRACE(
+ StringPrintf("case %" PRIuS " \"%s\"", i, cases[i].input.c_str()));
double output;
errno = 1;
EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output));
@@ -814,13 +866,14 @@
double input;
const char* expected;
} cases[] = {
- {0.0, "0"},
- {1.25, "1.25"},
- {1.33518e+012, "1.33518e+12"},
- {1.33489e+012, "1.33489e+12"},
- {1.33505e+012, "1.33505e+12"},
- {1.33545e+009, "1335450000"},
- {1.33503e+009, "1335030000"},
+ {0.0, "0"},
+ {0.5, "0.5"},
+ {1.25, "1.25"},
+ {1.33518e+012, "1.33518e+12"},
+ {1.33489e+012, "1.33489e+12"},
+ {1.33505e+012, "1.33505e+12"},
+ {1.33545e+009, "1335450000"},
+ {1.33503e+009, "1335030000"},
};
for (const auto& i : cases) {
@@ -832,12 +885,12 @@
const char input_bytes[8] = {0, 0, 0, 0, '\xee', '\x6d', '\x73', '\x42'};
double input = 0;
memcpy(&input, input_bytes, gurl_base::size(input_bytes));
- EXPECT_EQ("1335179083776", NumberToString(input));
+ EXPECT_EQ("1.335179083776e+12", NumberToString(input));
const char input_bytes2[8] =
{0, 0, 0, '\xa0', '\xda', '\x6c', '\x73', '\x42'};
input = 0;
memcpy(&input, input_bytes2, gurl_base::size(input_bytes2));
- EXPECT_EQ("1334890332160", NumberToString(input));
+ EXPECT_EQ("1.33489033216e+12", NumberToString(input));
}
TEST(StringNumberConversionsTest, HexEncode) {
@@ -892,6 +945,7 @@
};
for (const auto& test : cases) {
+ SCOPED_TRACE(StringPrintf("input: \"%s\"", test.input));
double output;
EXPECT_TRUE(StringToDouble(test.input, &output));
EXPECT_EQ(bit_cast<uint64_t>(output), test.expected);
diff --git a/base/strings/string_piece.cc b/base/strings/string_piece.cc
index 68f3efc..74f3335 100644
--- a/base/strings/string_piece.cc
+++ b/base/strings/string_piece.cc
@@ -53,36 +53,6 @@
namespace internal {
template<typename STR>
-void CopyToStringT(const BasicStringPiece<STR>& self, STR* target) {
- if (self.empty())
- target->clear();
- else
- target->assign(self.data(), self.size());
-}
-
-void CopyToString(const StringPiece& self, std::string* target) {
- CopyToStringT(self, target);
-}
-
-void CopyToString(const StringPiece16& self, string16* target) {
- CopyToStringT(self, target);
-}
-
-template<typename STR>
-void AppendToStringT(const BasicStringPiece<STR>& self, STR* target) {
- if (!self.empty())
- target->append(self.data(), self.size());
-}
-
-void AppendToString(const StringPiece& self, std::string* target) {
- AppendToStringT(self, target);
-}
-
-void AppendToString(const StringPiece16& self, string16* target) {
- AppendToStringT(self, target);
-}
-
-template<typename STR>
size_t copyT(const BasicStringPiece<STR>& self,
typename STR::value_type* buf,
size_t n,
@@ -219,8 +189,11 @@
size_t find_first_of(const StringPiece16& self,
const StringPiece16& s,
size_t pos) {
+ // Use the faster std::find() if searching for a single character.
StringPiece16::const_iterator found =
- std::find_first_of(self.begin() + pos, self.end(), s.begin(), s.end());
+ s.size() == 1 ? std::find(self.begin() + pos, self.end(), s[0])
+ : std::find_first_of(self.begin() + pos, self.end(),
+ s.begin(), s.end());
if (found == self.end())
return StringPiece16::npos;
return found - self.begin();
@@ -435,16 +408,5 @@
return substrT(self, pos, n);
}
-#if GURL_DCHECK_IS_ON()
-void AssertIteratorsInOrder(std::string::const_iterator begin,
- std::string::const_iterator end) {
- GURL_DCHECK(begin <= end) << "StringPiece iterators swapped or invalid.";
-}
-void AssertIteratorsInOrder(string16::const_iterator begin,
- string16::const_iterator end) {
- GURL_DCHECK(begin <= end) << "StringPiece iterators swapped or invalid.";
-}
-#endif
-
} // namespace internal
} // namespace base
diff --git a/base/strings/string_piece.h b/base/strings/string_piece.h
index 5359af6..964ec67 100644
--- a/base/strings/string_piece.h
+++ b/base/strings/string_piece.h
@@ -47,12 +47,6 @@
// template internal to the .cc file.
namespace internal {
-BASE_EXPORT void CopyToString(const StringPiece& self, std::string* target);
-BASE_EXPORT void CopyToString(const StringPiece16& self, string16* target);
-
-BASE_EXPORT void AppendToString(const StringPiece& self, std::string* target);
-BASE_EXPORT void AppendToString(const StringPiece16& self, string16* target);
-
BASE_EXPORT size_t copy(const StringPiece& self,
char* buf,
size_t n,
@@ -141,21 +135,12 @@
size_t pos,
size_t n);
-#if GURL_DCHECK_IS_ON()
-// Asserts that begin <= end to catch some errors with iterator usage.
-BASE_EXPORT void AssertIteratorsInOrder(std::string::const_iterator begin,
- std::string::const_iterator end);
-BASE_EXPORT void AssertIteratorsInOrder(string16::const_iterator begin,
- string16::const_iterator end);
-#endif
-
} // namespace internal
// BasicStringPiece ------------------------------------------------------------
// Defines the types, methods, operators, and data members common to both
-// StringPiece and StringPiece16. Do not refer to this class directly, but
-// rather to BasicStringPiece, StringPiece, or StringPiece16.
+// StringPiece and StringPiece16.
//
// This is templatized by string class type rather than character type, so
// BasicStringPiece<std::string> or BasicStringPiece<gurl_base::string16>.
@@ -178,23 +163,32 @@
// in a "const char*" or a "string" wherever a "StringPiece" is
// expected (likewise for char16, string16, StringPiece16).
constexpr BasicStringPiece() : ptr_(NULL), length_(0) {}
- // TODO(dcheng): Construction from nullptr is not allowed for
+ // 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
// isn't constexpr until C++17.
constexpr BasicStringPiece(const value_type* str)
: ptr_(str), length_(!str ? 0 : CharTraits<value_type>::length(str)) {}
+ // Explicitly disallow construction from nullptr. Note that this does not
+ // catch construction from runtime strings that might be null.
+ // Note: The following is just a more elaborate way of spelling
+ // `BasicStringPiece(nullptr_t) = delete`, but unfortunately the terse form is
+ // not supported by the PNaCl toolchain.
+ // TODO(crbug.com/1049498): Remove once we GURL_CHECK(str) in the constructor
+ // above.
+ template <class T, class = std::enable_if_t<std::is_null_pointer<T>::value>>
+ BasicStringPiece(T) {
+ static_assert(sizeof(T) == 0, // Always false.
+ "StringPiece does not support construction from nullptr, use "
+ "the default constructor instead.");
+ }
BasicStringPiece(const STRING_TYPE& str)
: ptr_(str.data()), length_(str.size()) {}
constexpr BasicStringPiece(const value_type* offset, size_type len)
: ptr_(offset), length_(len) {}
BasicStringPiece(const typename STRING_TYPE::const_iterator& begin,
const typename STRING_TYPE::const_iterator& end) {
-#if GURL_DCHECK_IS_ON()
- // This assertion is done out-of-line to avoid bringing in logging.h and
- // instantiating logging macros for every instantiation.
- internal::AssertIteratorsInOrder(begin, end);
-#endif
+ GURL_DCHECK(begin <= end) << "StringPiece iterators swapped or invalid.";
length_ = static_cast<size_t>(std::distance(begin, end));
// The length test before assignment is to avoid dereferencing an iterator
@@ -211,19 +205,6 @@
constexpr size_type length() const noexcept { return length_; }
bool empty() const { return length_ == 0; }
- void clear() {
- ptr_ = NULL;
- length_ = 0;
- }
- void set(const value_type* data, size_type len) {
- ptr_ = data;
- length_ = len;
- }
- void set(const value_type* str) {
- ptr_ = str;
- length_ = str ? STRING_TYPE::traits_type::length(str) : 0;
- }
-
constexpr value_type operator[](size_type i) const {
GURL_CHECK(i < length_);
return ptr_[i];
@@ -280,16 +261,6 @@
size_type max_size() const { return length_; }
size_type capacity() const { return length_; }
- // Sets the value of the given string target type to be the current string.
- // This saves a temporary over doing |a = b.as_string()|
- void CopyToString(STRING_TYPE* target) const {
- internal::CopyToString(*this, target);
- }
-
- void AppendToString(STRING_TYPE* target) const {
- internal::AppendToString(*this, target);
- }
-
size_type copy(value_type* buf, size_type n, size_type pos = 0) const {
return internal::copy(*this, buf, n, pos);
}
diff --git a/base/strings/string_piece_unittest.cc b/base/strings/string_piece_unittest.cc
index 8e245e6..0777549 100644
--- a/base/strings/string_piece_unittest.cc
+++ b/base/strings/string_piece_unittest.cc
@@ -190,7 +190,7 @@
ASSERT_TRUE(e.empty());
ASSERT_EQ(e.begin(), e.end());
- d.clear();
+ d = BasicStringPiece<TypeParam>();
ASSERT_EQ(d.size(), 0U);
ASSERT_TRUE(d.empty());
ASSERT_EQ(d.data(), nullptr);
@@ -213,7 +213,7 @@
BasicStringPiece<TypeParam> c(xyz);
BasicStringPiece<TypeParam> d(foobar);
- d.clear();
+ d = Piece();
Piece e;
TypeParam temp(TestFixture::as_string("123"));
temp.push_back('\0');
@@ -511,14 +511,14 @@
c.remove_suffix(c.size());
ASSERT_EQ(c, e);
- // set
- c.set(foobar.c_str());
+ // assignment
+ c = foobar.c_str();
ASSERT_EQ(c, a);
- c.set(foobar.c_str(), 6);
+ c = {foobar.c_str(), 6};
ASSERT_EQ(c, a);
- c.set(foobar.c_str(), 0);
+ c = {foobar.c_str(), 0};
ASSERT_EQ(c, e);
- c.set(foobar.c_str(), 7); // Note, has an embedded NULL
+ c = {foobar.c_str(), 7}; // Note, has an embedded NULL
ASSERT_NE(c, a);
// as_string
@@ -543,25 +543,6 @@
StringPiece e;
std::string s2;
- // CopyToString
- a.CopyToString(&s2);
- ASSERT_EQ(s2.size(), 6U);
- ASSERT_EQ(s2, "foobar");
- b.CopyToString(&s2);
- ASSERT_EQ(s2.size(), 7U);
- ASSERT_EQ(s1, s2);
- e.CopyToString(&s2);
- ASSERT_TRUE(s2.empty());
-
- // AppendToString
- s2.erase();
- a.AppendToString(&s2);
- ASSERT_EQ(s2.size(), 6U);
- ASSERT_EQ(s2, "foobar");
- a.AppendToString(&s2);
- ASSERT_EQ(s2.size(), 12U);
- ASSERT_EQ(s2, "foobarfoobar");
-
// starts_with
ASSERT_TRUE(a.starts_with(a));
ASSERT_TRUE(a.starts_with("foo"));
@@ -587,21 +568,16 @@
ASSERT_TRUE(!e.ends_with(a));
StringPiece c;
- c.set("foobar", 6);
+ c = {"foobar", 6};
ASSERT_EQ(c, a);
- c.set("foobar", 0);
+ c = {"foobar", 0};
ASSERT_EQ(c, e);
- c.set("foobar", 7);
+ c = {"foobar", 7};
ASSERT_NE(c, a);
}
TYPED_TEST(CommonStringPieceTest, CheckNULL) {
- // we used to crash here, but now we don't.
- BasicStringPiece<TypeParam> s(nullptr);
- ASSERT_EQ(s.data(), nullptr);
- ASSERT_EQ(s.size(), 0U);
-
- s.set(nullptr);
+ BasicStringPiece<TypeParam> s;
ASSERT_EQ(s.data(), nullptr);
ASSERT_EQ(s.size(), 0U);
@@ -699,7 +675,7 @@
BasicStringPiece<TypeParam>(
str.c_str(),
static_cast<typename BasicStringPiece<TypeParam>::size_type>(0)));
- ASSERT_EQ(empty, BasicStringPiece<TypeParam>(nullptr));
+ ASSERT_EQ(empty, BasicStringPiece<TypeParam>());
ASSERT_TRUE(
empty ==
BasicStringPiece<TypeParam>(
diff --git a/base/strings/string_split.cc b/base/strings/string_split.cc
index ef9c74d..3816501 100644
--- a/base/strings/string_split.cc
+++ b/base/strings/string_split.cc
@@ -14,27 +14,15 @@
namespace {
-// PieceToOutputType converts a StringPiece as needed to a given output type,
-// which is either the same type of StringPiece (a NOP) or the corresponding
-// non-piece string type.
-//
-// The default converter is a NOP, it works when the OutputType is the
-// correct StringPiece.
-template<typename Str, typename OutputType>
-OutputType PieceToOutputType(BasicStringPiece<Str> piece) {
- return piece;
-}
-template<> // Convert StringPiece to std::string
-std::string PieceToOutputType<std::string, std::string>(StringPiece piece) {
- return piece.as_string();
-}
-template<> // Convert StringPiece16 to string16.
-string16 PieceToOutputType<string16, string16>(StringPiece16 piece) {
- return piece.as_string();
-}
-
// 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;
}
@@ -42,37 +30,12 @@
return kWhitespaceASCII;
}
-// Optimize the single-character case to call find() on the string instead,
-// since this is the common case and can be made faster. This could have been
-// done with template specialization too, but would have been less clear.
-//
-// There is no corresponding FindFirstNotOf because StringPiece already
-// implements these different versions that do the optimized searching.
-size_t FindFirstOf(StringPiece piece, char c, size_t pos) {
- return piece.find(c, pos);
-}
-size_t FindFirstOf(StringPiece16 piece, char16 c, size_t pos) {
- return piece.find(c, pos);
-}
-size_t FindFirstOf(StringPiece piece, StringPiece one_of, size_t pos) {
- return piece.find_first_of(one_of, pos);
-}
-size_t FindFirstOf(StringPiece16 piece, StringPiece16 one_of, size_t pos) {
- return piece.find_first_of(one_of, pos);
-}
-
// General string splitter template. Can take 8- or 16-bit input, can produce
-// the corresponding string or StringPiece output, and can take single- or
-// multiple-character delimiters.
-//
-// DelimiterType is either a character (Str::value_type) or a string piece of
-// multiple characters (BasicStringPiece<Str>). StringPiece has a version of
-// find for both of these cases, and the single-character version is the most
-// common and can be implemented faster, which is why this is a template.
-template<typename Str, typename OutputStringType, typename DelimiterType>
+// the corresponding string or StringPiece output.
+template <typename OutputStringType, typename Str>
static std::vector<OutputStringType> SplitStringT(
BasicStringPiece<Str> str,
- DelimiterType delimiter,
+ BasicStringPiece<Str> delimiter,
WhitespaceHandling whitespace,
SplitResult result_type) {
std::vector<OutputStringType> result;
@@ -81,7 +44,7 @@
size_t start = 0;
while (start != Str::npos) {
- size_t end = FindFirstOf(str, delimiter, start);
+ size_t end = str.find_first_of(delimiter, start);
BasicStringPiece<Str> piece;
if (end == Str::npos) {
@@ -96,7 +59,7 @@
piece = TrimString(piece, WhitespaceForType<Str>(), TRIM_ALL);
if (result_type == SPLIT_WANT_ALL || !piece.empty())
- result.push_back(PieceToOutputType<Str, OutputStringType>(piece));
+ result.emplace_back(piece);
}
return result;
}
@@ -115,7 +78,7 @@
DVLOG(1) << "cannot find delimiter in: " << input;
return false; // No delimiter.
}
- input.substr(0, end_key_pos).CopyToString(&result_pair.first);
+ result_pair.first = std::string(input.substr(0, end_key_pos));
// Find the value string.
StringPiece remains = input.substr(end_key_pos, input.size() - end_key_pos);
@@ -124,22 +87,23 @@
DVLOG(1) << "cannot parse value from input: " << input;
return false; // No value.
}
- remains.substr(begin_value_pos, remains.size() - begin_value_pos)
- .CopyToString(&result_pair.second);
+
+ result_pair.second = std::string(
+ remains.substr(begin_value_pos, remains.size() - begin_value_pos));
return true;
}
-template <typename Str, typename OutputStringType>
-void SplitStringUsingSubstrT(BasicStringPiece<Str> input,
- BasicStringPiece<Str> delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type,
- std::vector<OutputStringType>* 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;
- result->clear();
+ 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);
@@ -151,8 +115,10 @@
term = TrimString(term, WhitespaceForType<Str>(), TRIM_ALL);
if (result_type == SPLIT_WANT_ALL || !term.empty())
- result->push_back(PieceToOutputType<Str, OutputStringType>(term));
+ result.emplace_back(term);
}
+
+ return result;
}
} // namespace
@@ -161,48 +127,29 @@
StringPiece separators,
WhitespaceHandling whitespace,
SplitResult result_type) {
- if (separators.size() == 1) {
- return SplitStringT<std::string, std::string, char>(
- input, separators[0], whitespace, result_type);
- }
- return SplitStringT<std::string, std::string, StringPiece>(
- input, separators, whitespace, result_type);
+ return SplitStringT<std::string>(input, separators, whitespace, result_type);
}
std::vector<string16> SplitString(StringPiece16 input,
StringPiece16 separators,
WhitespaceHandling whitespace,
SplitResult result_type) {
- if (separators.size() == 1) {
- return SplitStringT<string16, string16, char16>(
- input, separators[0], whitespace, result_type);
- }
- return SplitStringT<string16, string16, StringPiece16>(
- input, separators, whitespace, result_type);
+ return SplitStringT<string16>(input, separators, whitespace, result_type);
}
std::vector<StringPiece> SplitStringPiece(StringPiece input,
StringPiece separators,
WhitespaceHandling whitespace,
SplitResult result_type) {
- if (separators.size() == 1) {
- return SplitStringT<std::string, StringPiece, char>(
- input, separators[0], whitespace, result_type);
- }
- return SplitStringT<std::string, StringPiece, StringPiece>(
- input, separators, whitespace, result_type);
+ return SplitStringT<StringPiece>(input, separators, whitespace, result_type);
}
std::vector<StringPiece16> SplitStringPiece(StringPiece16 input,
StringPiece16 separators,
WhitespaceHandling whitespace,
SplitResult result_type) {
- if (separators.size() == 1) {
- return SplitStringT<string16, StringPiece16, char16>(
- input, separators[0], whitespace, result_type);
- }
- return SplitStringT<string16, StringPiece16, StringPiece16>(
- input, separators, whitespace, result_type);
+ return SplitStringT<StringPiece16>(input, separators, whitespace,
+ result_type);
}
bool SplitStringIntoKeyValuePairs(StringPiece input,
@@ -240,18 +187,16 @@
StringPiece16 delimiter,
WhitespaceHandling whitespace,
SplitResult result_type) {
- std::vector<string16> result;
- SplitStringUsingSubstrT(input, delimiter, whitespace, result_type, &result);
- return result;
+ return SplitStringUsingSubstrT<string16>(input, delimiter, whitespace,
+ result_type);
}
std::vector<std::string> SplitStringUsingSubstr(StringPiece input,
StringPiece delimiter,
WhitespaceHandling whitespace,
SplitResult result_type) {
- std::vector<std::string> result;
- SplitStringUsingSubstrT(input, delimiter, whitespace, result_type, &result);
- return result;
+ return SplitStringUsingSubstrT<std::string>(input, delimiter, whitespace,
+ result_type);
}
std::vector<StringPiece16> SplitStringPieceUsingSubstr(
@@ -260,8 +205,8 @@
WhitespaceHandling whitespace,
SplitResult result_type) {
std::vector<StringPiece16> result;
- SplitStringUsingSubstrT(input, delimiter, whitespace, result_type, &result);
- return result;
+ return SplitStringUsingSubstrT<StringPiece16>(input, delimiter, whitespace,
+ result_type);
}
std::vector<StringPiece> SplitStringPieceUsingSubstr(
@@ -269,9 +214,41 @@
StringPiece delimiter,
WhitespaceHandling whitespace,
SplitResult result_type) {
- std::vector<StringPiece> result;
- SplitStringUsingSubstrT(input, delimiter, whitespace, result_type, &result);
- return result;
+ return 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 1894d05..02c2c59 100644
--- a/base/strings/string_split.h
+++ b/base/strings/string_split.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 {
@@ -39,26 +40,31 @@
// Split the given string on ANY of the given separators, returning copies of
// the result.
//
+// Note this is inverse of JoinString() defined in string_util.h.
+//
// To split on either commas or semicolons, keeping all whitespace:
//
// std::vector<std::string> tokens = gurl_base::SplitString(
-// input, ",;", gurl_base::KEEP_WHITESPACE, gurl_base::SPLIT_WANT_ALL);
-BASE_EXPORT std::vector<std::string> SplitString(
- StringPiece input,
- StringPiece separators,
- WhitespaceHandling whitespace,
- SplitResult result_type);
-BASE_EXPORT std::vector<string16> SplitString(
- StringPiece16 input,
- StringPiece16 separators,
- WhitespaceHandling whitespace,
- SplitResult result_type);
+// input, ", WARN_UNUSED_RESULT;", gurl_base::KEEP_WHITESPACE,
+// gurl_base::SPLIT_WANT_ALL) WARN_UNUSED_RESULT;
+BASE_EXPORT std::vector<std::string> SplitString(StringPiece input,
+ StringPiece separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type)
+ WARN_UNUSED_RESULT;
+BASE_EXPORT std::vector<string16> SplitString(StringPiece16 input,
+ StringPiece16 separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type)
+ WARN_UNUSED_RESULT;
// Like SplitString above except it returns a vector of StringPieces which
// reference the original buffer without copying. Although you have to be
// careful to keep the original string unmodified, this provides an efficient
// way to iterate through tokens in a string.
//
+// Note this is inverse of JoinString() defined in string_util.h.
+//
// To iterate through all whitespace-separated tokens in an input string:
//
// for (const auto& cur :
@@ -70,12 +76,12 @@
StringPiece input,
StringPiece separators,
WhitespaceHandling whitespace,
- SplitResult result_type);
+ SplitResult result_type) WARN_UNUSED_RESULT;
BASE_EXPORT std::vector<StringPiece16> SplitStringPiece(
StringPiece16 input,
StringPiece16 separators,
WhitespaceHandling whitespace,
- SplitResult result_type);
+ SplitResult result_type) WARN_UNUSED_RESULT;
using StringPairs = std::vector<std::pair<std::string, std::string>>;
@@ -102,12 +108,12 @@
StringPiece16 input,
StringPiece16 delimiter,
WhitespaceHandling whitespace,
- SplitResult result_type);
+ SplitResult result_type) WARN_UNUSED_RESULT;
BASE_EXPORT std::vector<std::string> SplitStringUsingSubstr(
StringPiece input,
StringPiece delimiter,
WhitespaceHandling whitespace,
- SplitResult result_type);
+ SplitResult result_type) WARN_UNUSED_RESULT;
// Like SplitStringUsingSubstr above except it returns a vector of StringPieces
// which reference the original buffer without copying. Although you have to be
@@ -125,12 +131,38 @@
StringPiece16 input,
StringPiece16 delimiter,
WhitespaceHandling whitespace,
- SplitResult result_type);
+ SplitResult result_type) WARN_UNUSED_RESULT;
BASE_EXPORT std::vector<StringPiece> SplitStringPieceUsingSubstr(
StringPiece input,
StringPiece delimiter,
WhitespaceHandling whitespace,
- SplitResult result_type);
+ 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
diff --git a/base/strings/string_split_unittest.cc b/base/strings/string_split_unittest.cc
index 993450a..f84d4b8 100644
--- a/base/strings/string_split_unittest.cc
+++ b/base/strings/string_split_unittest.cc
@@ -47,7 +47,7 @@
}
TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest,
- MissingKeyValuePairDelimeter) {
+ MissingKeyValuePairDelimiter) {
EXPECT_TRUE(SplitStringIntoKeyValuePairsUsingSubstr(
"key1:value1,,key3:value3",
':', // Key-value delimiter
diff --git a/base/strings/string_util.cc b/base/strings/string_util.cc
index 2b2591d..742319a 100644
--- a/base/strings/string_util.cc
+++ b/base/strings/string_util.cc
@@ -51,21 +51,6 @@
return elem1.parameter < elem2.parameter;
}
-// Overloaded function to append one string onto the end of another. Having a
-// separate overload for |source| as both string and StringPiece allows for more
-// efficient usage from functions templated to work with either type (avoiding a
-// redundant call to the BasicStringPiece constructor in both cases).
-template <typename string_type>
-inline void AppendToString(string_type* target, const string_type& source) {
- target->append(source);
-}
-
-template <typename string_type>
-inline void AppendToString(string_type* target,
- const BasicStringPiece<string_type>& source) {
- source.AppendToString(target);
-}
-
// 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;
@@ -237,17 +222,16 @@
bool ReplaceChars(const string16& input,
StringPiece16 replace_chars,
- const string16& replace_with,
+ StringPiece16 replace_with,
string16* output) {
- return ReplaceCharsT(input, replace_chars, StringPiece16(replace_with),
- output);
+ return ReplaceCharsT(input, replace_chars, replace_with, output);
}
bool ReplaceChars(const std::string& input,
StringPiece replace_chars,
- const std::string& replace_with,
+ StringPiece replace_with,
std::string* output) {
- return ReplaceCharsT(input, replace_chars, StringPiece(replace_with), output);
+ return ReplaceCharsT(input, replace_chars, replace_with, output);
}
bool RemoveChars(const string16& input,
@@ -262,8 +246,8 @@
return ReplaceCharsT(input, remove_chars, StringPiece(), output);
}
-template<typename Str>
-TrimPositions TrimStringT(const Str& input,
+template <typename Str>
+TrimPositions TrimStringT(BasicStringPiece<Str> input,
BasicStringPiece<Str> trim_chars,
TrimPositions positions,
Str* output) {
@@ -271,40 +255,40 @@
// 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).
- BasicStringPiece<Str> input_piece(input);
const size_t last_char = input.length() - 1;
- const size_t first_good_char = (positions & TRIM_LEADING) ?
- input_piece.find_first_not_of(trim_chars) : 0;
- const size_t last_good_char = (positions & TRIM_TRAILING) ?
- input_piece.find_last_not_of(trim_chars) : last_char;
+ 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)) {
+ 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 =
- input.substr(first_good_char, last_good_char - first_good_char + 1);
+ 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));
+ (first_good_char == 0 ? TRIM_NONE : TRIM_LEADING) |
+ (last_good_char == last_char ? TRIM_NONE : TRIM_TRAILING));
}
-bool TrimString(const string16& input,
+bool TrimString(StringPiece16 input,
StringPiece16 trim_chars,
string16* output) {
return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
}
-bool TrimString(const std::string& input,
+bool TrimString(StringPiece input,
StringPiece trim_chars,
std::string* output) {
return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
@@ -370,7 +354,7 @@
output->clear();
}
-TrimPositions TrimWhitespace(const string16& input,
+TrimPositions TrimWhitespace(StringPiece16 input,
TrimPositions positions,
string16* output) {
return TrimStringT(input, StringPiece16(kWhitespaceUTF16), positions, output);
@@ -381,7 +365,7 @@
return TrimStringPieceT(input, StringPiece16(kWhitespaceUTF16), positions);
}
-TrimPositions TrimWhitespaceASCII(const std::string& input,
+TrimPositions TrimWhitespaceASCII(StringPiece input,
TrimPositions positions,
std::string* output) {
return TrimStringT(input, StringPiece(kWhitespaceASCII), positions, output);
@@ -506,20 +490,29 @@
}
#endif
-bool IsStringUTF8(StringPiece str) {
- const char *src = str.data();
+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 (!IsValidCharacter(code_point))
+ if (!Validator(code_point))
return false;
}
return true;
}
+bool IsStringUTF8(StringPiece str) {
+ return 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
@@ -913,7 +906,7 @@
template <class string_type>
inline typename string_type::value_type* WriteIntoT(string_type* str,
size_t length_with_null) {
- GURL_DCHECK_GT(length_with_null, 1u);
+ GURL_DCHECK_GE(length_with_null, 1u);
str->reserve(length_with_null);
str->resize(length_with_null - 1);
return &((*str)[0]);
@@ -927,11 +920,6 @@
return WriteIntoT(str, length_with_null);
}
-#if defined(_MSC_VER) && !defined(__clang__)
-// Work around VC++ code-gen bug. https://crbug.com/804884
-#pragma optimize("", off)
-#endif
-
// 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
@@ -939,7 +927,7 @@
template <typename list_type, typename string_type>
static string_type JoinStringT(const list_type& parts,
BasicStringPiece<string_type> sep) {
- if (parts.size() == 0)
+ if (gurl_base::empty(parts))
return string_type();
// Pre-allocate the eventual size of the string. Start with the size of all of
@@ -952,15 +940,12 @@
auto iter = parts.begin();
GURL_DCHECK(iter != parts.end());
- AppendToString(&result, *iter);
+ result.append(iter->data(), iter->size());
++iter;
for (; iter != parts.end(); ++iter) {
- sep.AppendToString(&result);
- // Using the overloaded AppendToString allows this template function to work
- // on both strings and StringPieces without creating an intermediate
- // StringPiece object.
- AppendToString(&result, *iter);
+ result.append(sep.data(), sep.size());
+ result.append(iter->data(), iter->size());
}
// Sanity-check that we pre-allocated correctly.
@@ -979,11 +964,6 @@
return JoinStringT(parts, separator);
}
-#if defined(_MSC_VER) && !defined(__clang__)
-// Work around VC++ code-gen bug. https://crbug.com/804884
-#pragma optimize("", on)
-#endif
-
std::string JoinString(const std::vector<StringPiece>& parts,
StringPiece separator) {
return JoinStringT(parts, separator);
@@ -1085,6 +1065,36 @@
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
diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index 5a8cb02..ed3118d 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -160,6 +160,7 @@
// by HTML5, and don't include control characters.
BASE_EXPORT extern const wchar_t kWhitespaceWide[]; // Includes Unicode.
BASE_EXPORT extern const char16 kWhitespaceUTF16[]; // Includes Unicode.
+BASE_EXPORT extern const char16 kWhitespaceNoCrLfUTF16[]; // Unicode w/o CR/LF.
BASE_EXPORT extern const char kWhitespaceASCII[];
BASE_EXPORT extern const char16 kWhitespaceASCIIAs16[]; // No unicode.
@@ -183,11 +184,11 @@
// NOTE: Safe to use the same variable for both |input| and |output|.
BASE_EXPORT bool ReplaceChars(const string16& input,
StringPiece16 replace_chars,
- const string16& replace_with,
+ StringPiece16 replace_with,
string16* output);
BASE_EXPORT bool ReplaceChars(const std::string& input,
StringPiece replace_chars,
- const std::string& replace_with,
+ StringPiece replace_with,
std::string* output);
enum TrimPositions {
@@ -203,10 +204,10 @@
//
// It is safe to use the same variable for both |input| and |output| (this is
// the normal usage to trim in-place).
-BASE_EXPORT bool TrimString(const string16& input,
+BASE_EXPORT bool TrimString(StringPiece16 input,
StringPiece16 trim_chars,
string16* output);
-BASE_EXPORT bool TrimString(const std::string& input,
+BASE_EXPORT bool TrimString(StringPiece input,
StringPiece trim_chars,
std::string* output);
@@ -268,6 +269,24 @@
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.
@@ -277,12 +296,12 @@
//
// The std::string versions return where whitespace was found.
// NOTE: Safe to use the same variable for both input and output.
-BASE_EXPORT TrimPositions TrimWhitespace(const string16& input,
+BASE_EXPORT TrimPositions TrimWhitespace(StringPiece16 input,
TrimPositions positions,
string16* output);
BASE_EXPORT StringPiece16 TrimWhitespace(StringPiece16 input,
TrimPositions positions);
-BASE_EXPORT TrimPositions TrimWhitespaceASCII(const std::string& input,
+BASE_EXPORT TrimPositions TrimWhitespaceASCII(StringPiece input,
TrimPositions positions,
std::string* output);
BASE_EXPORT StringPiece TrimWhitespaceASCII(StringPiece input,
@@ -309,21 +328,23 @@
BASE_EXPORT bool ContainsOnlyChars(StringPiece16 input,
StringPiece16 characters);
-// Returns true if the specified string matches the criteria. How can a wide
-// string be 8-bit or UTF8? It contains only characters that are < 256 (in the
-// first case) or characters that use only 8-bits and whose 8-bit
-// representation looks like a UTF-8 string (the second case).
-//
-// Note that IsStringUTF8 checks not only if the input is structurally
-// valid but also if it doesn't contain any non-character codepoint
-// (e.g. U+FFFE). It's done on purpose because all the existing callers want
-// to have the maximum 'discriminating' power from other encodings. If
-// there's a use case for just checking the structural validity, we have to
-// add a new function for that.
-//
-// IsStringASCII assumes the input is likely all ASCII, and does not leave early
-// if it is not the case.
+// Returns true if |str| is structurally valid UTF-8 and also doesn't
+// contain any non-character code point (e.g. U+10FFFE). Prohibiting
+// non-characters increases the likelihood of detecting non-UTF-8 in
+// real-world text, for callers which do not need to accept
+// non-characters in strings.
BASE_EXPORT bool IsStringUTF8(StringPiece str);
+
+// Returns true if |str| contains valid UTF-8, allowing non-character
+// code points.
+BASE_EXPORT bool IsStringUTF8AllowingNoncharacters(StringPiece str);
+
+// Returns true if |str| contains only valid ASCII character values.
+// Note 1: IsStringASCII executes in time determined solely by the
+// length of the string, not by its contents, so it is robust against
+// timing attacks for all strings of equal length.
+// Note 2: IsStringASCII assumes the input is likely all ASCII, and
+// 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)
@@ -456,10 +477,6 @@
// convenient in that is can be used inline in the call, and fast in that it
// avoids copying the results of the call from a char* into a string.
//
-// |length_with_null| must be at least 2, since otherwise the underlying string
-// would have size 0, and trying to access &((*str)[0]) in that case can result
-// in a number of problems.
-//
// Internally, this takes linear time because the resize() call 0-fills the
// underlying array for potentially all
// (|length_with_null - 1| * sizeof(string_type::value_type)) bytes. Ideally we
@@ -471,9 +488,11 @@
BASE_EXPORT char* WriteInto(std::string* str, size_t length_with_null);
BASE_EXPORT char16* WriteInto(string16* str, size_t length_with_null);
-// Does the opposite of SplitString()/SplitStringPiece(). Joins a vector or list
-// of strings into a single string, inserting |separator| (which may be empty)
-// in between all elements.
+// Joins a vector or 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.
//
// If possible, callers should build a vector of StringPieces and use the
// StringPiece variant, so that they do not create unnecessary copies of
@@ -517,6 +536,25 @@
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_constants.cc b/base/strings/string_util_constants.cc
index 3ca29b7..e9e4d93 100644
--- a/base/strings/string_util_constants.cc
+++ b/base/strings/string_util_constants.cc
@@ -6,61 +6,48 @@
namespace gurl_base {
-#define WHITESPACE_UNICODE \
- 0x0009, /* CHARACTER TABULATION */ \
- 0x000A, /* LINE FEED (LF) */ \
- 0x000B, /* LINE TABULATION */ \
- 0x000C, /* FORM FEED (FF) */ \
- 0x000D, /* CARRIAGE RETURN (CR) */ \
- 0x0020, /* SPACE */ \
- 0x0085, /* NEXT LINE (NEL) */ \
- 0x00A0, /* NO-BREAK SPACE */ \
- 0x1680, /* OGHAM SPACE MARK */ \
- 0x2000, /* EN QUAD */ \
- 0x2001, /* EM QUAD */ \
- 0x2002, /* EN SPACE */ \
- 0x2003, /* EM SPACE */ \
- 0x2004, /* THREE-PER-EM SPACE */ \
- 0x2005, /* FOUR-PER-EM SPACE */ \
- 0x2006, /* SIX-PER-EM SPACE */ \
- 0x2007, /* FIGURE SPACE */ \
- 0x2008, /* PUNCTUATION SPACE */ \
- 0x2009, /* THIN SPACE */ \
- 0x200A, /* HAIR SPACE */ \
- 0x2028, /* LINE SEPARATOR */ \
- 0x2029, /* PARAGRAPH SEPARATOR */ \
- 0x202F, /* NARROW NO-BREAK SPACE */ \
- 0x205F, /* MEDIUM MATHEMATICAL SPACE */ \
- 0x3000, /* IDEOGRAPHIC SPACE */ \
- 0
+#define WHITESPACE_ASCII_NO_CR_LF \
+ 0x09, /* CHARACTER TABULATION */ \
+ 0x0B, /* LINE TABULATION */ \
+ 0x0C, /* FORM FEED (FF) */ \
+ 0x20 /* SPACE */
-const wchar_t kWhitespaceWide[] = {
- WHITESPACE_UNICODE
-};
+#define WHITESPACE_ASCII \
+ WHITESPACE_ASCII_NO_CR_LF, /* Comment to make clang-format linebreak */ \
+ 0x0A, /* LINE FEED (LF) */ \
+ 0x0D /* CARRIAGE RETURN (CR) */
-const char16 kWhitespaceUTF16[] = {
- WHITESPACE_UNICODE
-};
+#define WHITESPACE_UNICODE_NON_ASCII \
+ 0x0085, /* NEXT LINE (NEL) */ \
+ 0x00A0, /* NO-BREAK SPACE */ \
+ 0x1680, /* OGHAM SPACE MARK */ \
+ 0x2000, /* EN QUAD */ \
+ 0x2001, /* EM QUAD */ \
+ 0x2002, /* EN SPACE */ \
+ 0x2003, /* EM SPACE */ \
+ 0x2004, /* THREE-PER-EM SPACE */ \
+ 0x2005, /* FOUR-PER-EM SPACE */ \
+ 0x2006, /* SIX-PER-EM SPACE */ \
+ 0x2007, /* FIGURE SPACE */ \
+ 0x2008, /* PUNCTUATION SPACE */ \
+ 0x2009, /* THIN SPACE */ \
+ 0x200A, /* HAIR SPACE */ \
+ 0x2028, /* LINE SEPARATOR */ \
+ 0x2029, /* PARAGRAPH SEPARATOR */ \
+ 0x202F, /* NARROW NO-BREAK SPACE */ \
+ 0x205F, /* MEDIUM MATHEMATICAL SPACE */ \
+ 0x3000 /* IDEOGRAPHIC SPACE */
-const char kWhitespaceASCII[] = {
- 0x09, // CHARACTER TABULATION
- 0x0A, // LINE FEED (LF)
- 0x0B, // LINE TABULATION
- 0x0C, // FORM FEED (FF)
- 0x0D, // CARRIAGE RETURN (CR)
- 0x20, // SPACE
- 0
-};
+#define WHITESPACE_UNICODE_NO_CR_LF \
+ WHITESPACE_ASCII_NO_CR_LF, WHITESPACE_UNICODE_NON_ASCII
-const char16 kWhitespaceASCIIAs16[] = {
- 0x09, // CHARACTER TABULATION
- 0x0A, // LINE FEED (LF)
- 0x0B, // LINE TABULATION
- 0x0C, // FORM FEED (FF)
- 0x0D, // CARRIAGE RETURN (CR)
- 0x20, // SPACE
- 0
-};
+#define WHITESPACE_UNICODE WHITESPACE_ASCII, WHITESPACE_UNICODE_NON_ASCII
+
+const wchar_t kWhitespaceWide[] = {WHITESPACE_UNICODE, 0};
+const char16 kWhitespaceUTF16[] = {WHITESPACE_UNICODE, 0};
+const char16 kWhitespaceNoCrLfUTF16[] = {WHITESPACE_UNICODE_NO_CR_LF, 0};
+const char kWhitespaceASCII[] = {WHITESPACE_ASCII, 0};
+const char16 kWhitespaceASCIIAs16[] = {WHITESPACE_ASCII, 0};
const char kUtf8ByteOrderMark[] = "\xEF\xBB\xBF";
diff --git a/base/strings/string_util_unittest.cc b/base/strings/string_util_unittest.cc
index 51b4ee1..a2aab42 100644
--- a/base/strings/string_util_unittest.cc
+++ b/base/strings/string_util_unittest.cc
@@ -69,6 +69,128 @@
return prev != output->length();
}
+using TestFunction = bool (*)(StringPiece str);
+
+// Helper used to test IsStringUTF8{,AllowingNoncharacters}.
+void TestStructurallyValidUtf8(TestFunction fn) {
+ EXPECT_TRUE(fn("abc"));
+ EXPECT_TRUE(fn("\xC2\x81"));
+ EXPECT_TRUE(fn("\xE1\x80\xBF"));
+ EXPECT_TRUE(fn("\xF1\x80\xA0\xBF"));
+ EXPECT_TRUE(fn("\xF1\x80\xA0\xBF"));
+ EXPECT_TRUE(fn("a\xC2\x81\xE1\x80\xBF\xF1\x80\xA0\xBF"));
+
+ // U+FEFF used as UTF-8 BOM.
+ // clang-format off
+ EXPECT_TRUE(fn("\xEF\xBB\xBF" "abc"));
+ // clang-format on
+
+ // Embedded nulls in canonical UTF-8 representation.
+ using std::string_literals::operator""s;
+ const std::string kEmbeddedNull = "embedded\0null"s;
+ EXPECT_TRUE(fn(kEmbeddedNull));
+}
+
+// Helper used to test IsStringUTF8{,AllowingNoncharacters}.
+void TestStructurallyInvalidUtf8(TestFunction fn) {
+ // Invalid encoding of U+1FFFE (0x8F instead of 0x9F)
+ EXPECT_FALSE(fn("\xF0\x8F\xBF\xBE"));
+
+ // Surrogate code points
+ EXPECT_FALSE(fn("\xED\xA0\x80\xED\xBF\xBF"));
+ EXPECT_FALSE(fn("\xED\xA0\x8F"));
+ EXPECT_FALSE(fn("\xED\xBF\xBF"));
+
+ // Overlong sequences
+ EXPECT_FALSE(fn("\xC0\x80")); // U+0000
+ EXPECT_FALSE(fn("\xC1\x80\xC1\x81")); // "AB"
+ EXPECT_FALSE(fn("\xE0\x80\x80")); // U+0000
+ EXPECT_FALSE(fn("\xE0\x82\x80")); // U+0080
+ EXPECT_FALSE(fn("\xE0\x9F\xBF")); // U+07FF
+ EXPECT_FALSE(fn("\xF0\x80\x80\x8D")); // U+000D
+ EXPECT_FALSE(fn("\xF0\x80\x82\x91")); // U+0091
+ EXPECT_FALSE(fn("\xF0\x80\xA0\x80")); // U+0800
+ EXPECT_FALSE(fn("\xF0\x8F\xBB\xBF")); // U+FEFF (BOM)
+ EXPECT_FALSE(fn("\xF8\x80\x80\x80\xBF")); // U+003F
+ EXPECT_FALSE(fn("\xFC\x80\x80\x80\xA0\xA5")); // U+00A5
+
+ // Beyond U+10FFFF (the upper limit of Unicode codespace)
+ EXPECT_FALSE(fn("\xF4\x90\x80\x80")); // U+110000
+ EXPECT_FALSE(fn("\xF8\xA0\xBF\x80\xBF")); // 5 bytes
+ EXPECT_FALSE(fn("\xFC\x9C\xBF\x80\xBF\x80")); // 6 bytes
+
+ // BOM in UTF-16(BE|LE)
+ EXPECT_FALSE(fn("\xFE\xFF"));
+ EXPECT_FALSE(fn("\xFF\xFE"));
+
+ // Strings in legacy encodings. We can certainly make up strings
+ // in a legacy encoding that are valid in UTF-8, but in real data,
+ // most of them are invalid as UTF-8.
+
+ // cafe with U+00E9 in ISO-8859-1
+ EXPECT_FALSE(fn("caf\xE9"));
+ // U+AC00, U+AC001 in EUC-KR
+ EXPECT_FALSE(fn("\xB0\xA1\xB0\xA2"));
+ // U+4F60 U+597D in Big5
+ EXPECT_FALSE(fn("\xA7\x41\xA6\x6E"));
+ // "abc" with U+201[CD] in windows-125[0-8]
+ // clang-format off
+ EXPECT_FALSE(fn("\x93" "abc\x94"));
+ // clang-format on
+ // U+0639 U+064E U+0644 U+064E in ISO-8859-6
+ EXPECT_FALSE(fn("\xD9\xEE\xE4\xEE"));
+ // U+03B3 U+03B5 U+03B9 U+03AC in ISO-8859-7
+ EXPECT_FALSE(fn("\xE3\xE5\xE9\xDC"));
+
+ // BOM in UTF-32(BE|LE)
+ using std::string_literals::operator""s;
+ const std::string kUtf32BeBom = "\x00\x00\xFE\xFF"s;
+ EXPECT_FALSE(fn(kUtf32BeBom));
+ const std::string kUtf32LeBom = "\xFF\xFE\x00\x00"s;
+ EXPECT_FALSE(fn(kUtf32LeBom));
+}
+
+// Helper used to test IsStringUTF8{,AllowingNoncharacters}.
+void TestNoncharacters(TestFunction fn, bool expected_result) {
+ EXPECT_EQ(fn("\xEF\xB7\x90"), expected_result); // U+FDD0
+ EXPECT_EQ(fn("\xEF\xB7\x9F"), expected_result); // U+FDDF
+ EXPECT_EQ(fn("\xEF\xB7\xAF"), expected_result); // U+FDEF
+ EXPECT_EQ(fn("\xEF\xBF\xBE"), expected_result); // U+FFFE
+ EXPECT_EQ(fn("\xEF\xBF\xBF"), expected_result); // U+FFFF
+ EXPECT_EQ(fn("\xF0\x9F\xBF\xBE"), expected_result); // U+01FFFE
+ EXPECT_EQ(fn("\xF0\x9F\xBF\xBF"), expected_result); // U+01FFFF
+ EXPECT_EQ(fn("\xF0\xAF\xBF\xBE"), expected_result); // U+02FFFE
+ EXPECT_EQ(fn("\xF0\xAF\xBF\xBF"), expected_result); // U+02FFFF
+ EXPECT_EQ(fn("\xF0\xBF\xBF\xBE"), expected_result); // U+03FFFE
+ EXPECT_EQ(fn("\xF0\xBF\xBF\xBF"), expected_result); // U+03FFFF
+ EXPECT_EQ(fn("\xF1\x8F\xBF\xBE"), expected_result); // U+04FFFE
+ EXPECT_EQ(fn("\xF1\x8F\xBF\xBF"), expected_result); // U+04FFFF
+ EXPECT_EQ(fn("\xF1\x9F\xBF\xBE"), expected_result); // U+05FFFE
+ EXPECT_EQ(fn("\xF1\x9F\xBF\xBF"), expected_result); // U+05FFFF
+ EXPECT_EQ(fn("\xF1\xAF\xBF\xBE"), expected_result); // U+06FFFE
+ EXPECT_EQ(fn("\xF1\xAF\xBF\xBF"), expected_result); // U+06FFFF
+ EXPECT_EQ(fn("\xF1\xBF\xBF\xBE"), expected_result); // U+07FFFE
+ EXPECT_EQ(fn("\xF1\xBF\xBF\xBF"), expected_result); // U+07FFFF
+ EXPECT_EQ(fn("\xF2\x8F\xBF\xBE"), expected_result); // U+08FFFE
+ EXPECT_EQ(fn("\xF2\x8F\xBF\xBF"), expected_result); // U+08FFFF
+ EXPECT_EQ(fn("\xF2\x9F\xBF\xBE"), expected_result); // U+09FFFE
+ EXPECT_EQ(fn("\xF2\x9F\xBF\xBF"), expected_result); // U+09FFFF
+ EXPECT_EQ(fn("\xF2\xAF\xBF\xBE"), expected_result); // U+0AFFFE
+ EXPECT_EQ(fn("\xF2\xAF\xBF\xBF"), expected_result); // U+0AFFFF
+ EXPECT_EQ(fn("\xF2\xBF\xBF\xBE"), expected_result); // U+0BFFFE
+ EXPECT_EQ(fn("\xF2\xBF\xBF\xBF"), expected_result); // U+0BFFFF
+ EXPECT_EQ(fn("\xF3\x8F\xBF\xBE"), expected_result); // U+0CFFFE
+ EXPECT_EQ(fn("\xF3\x8F\xBF\xBF"), expected_result); // U+0CFFFF
+ EXPECT_EQ(fn("\xF3\x9F\xBF\xBE"), expected_result); // U+0DFFFE
+ EXPECT_EQ(fn("\xF3\x9F\xBF\xBF"), expected_result); // U+0DFFFF
+ EXPECT_EQ(fn("\xF3\xAF\xBF\xBE"), expected_result); // U+0EFFFE
+ EXPECT_EQ(fn("\xF3\xAF\xBF\xBF"), expected_result); // U+0EFFFF
+ EXPECT_EQ(fn("\xF3\xBF\xBF\xBE"), expected_result); // U+0FFFFE
+ EXPECT_EQ(fn("\xF3\xBF\xBF\xBF"), expected_result); // U+0FFFFF
+ EXPECT_EQ(fn("\xF4\x8F\xBF\xBE"), expected_result); // U+10FFFE
+ EXPECT_EQ(fn("\xF4\x8F\xBF\xBF"), expected_result); // U+10FFFF
+}
+
} // namespace
TEST(StringUtilTest, TruncateUTF8ToByteSize) {
@@ -380,69 +502,19 @@
}
TEST(StringUtilTest, IsStringUTF8) {
- EXPECT_TRUE(IsStringUTF8("abc"));
- EXPECT_TRUE(IsStringUTF8("\xc2\x81"));
- EXPECT_TRUE(IsStringUTF8("\xe1\x80\xbf"));
- EXPECT_TRUE(IsStringUTF8("\xf1\x80\xa0\xbf"));
- EXPECT_TRUE(IsStringUTF8("a\xc2\x81\xe1\x80\xbf\xf1\x80\xa0\xbf"));
- EXPECT_TRUE(IsStringUTF8("\xef\xbb\xbf" "abc")); // UTF-8 BOM
+ {
+ SCOPED_TRACE("IsStringUTF8");
+ TestStructurallyValidUtf8(&IsStringUTF8);
+ TestStructurallyInvalidUtf8(&IsStringUTF8);
+ TestNoncharacters(&IsStringUTF8, false);
+ }
- // surrogate code points
- EXPECT_FALSE(IsStringUTF8("\xed\xa0\x80\xed\xbf\xbf"));
- EXPECT_FALSE(IsStringUTF8("\xed\xa0\x8f"));
- EXPECT_FALSE(IsStringUTF8("\xed\xbf\xbf"));
-
- // overlong sequences
- EXPECT_FALSE(IsStringUTF8("\xc0\x80")); // U+0000
- EXPECT_FALSE(IsStringUTF8("\xc1\x80\xc1\x81")); // "AB"
- EXPECT_FALSE(IsStringUTF8("\xe0\x80\x80")); // U+0000
- EXPECT_FALSE(IsStringUTF8("\xe0\x82\x80")); // U+0080
- EXPECT_FALSE(IsStringUTF8("\xe0\x9f\xbf")); // U+07ff
- EXPECT_FALSE(IsStringUTF8("\xf0\x80\x80\x8D")); // U+000D
- EXPECT_FALSE(IsStringUTF8("\xf0\x80\x82\x91")); // U+0091
- EXPECT_FALSE(IsStringUTF8("\xf0\x80\xa0\x80")); // U+0800
- EXPECT_FALSE(IsStringUTF8("\xf0\x8f\xbb\xbf")); // U+FEFF (BOM)
- EXPECT_FALSE(IsStringUTF8("\xf8\x80\x80\x80\xbf")); // U+003F
- EXPECT_FALSE(IsStringUTF8("\xfc\x80\x80\x80\xa0\xa5")); // U+00A5
-
- // Beyond U+10FFFF (the upper limit of Unicode codespace)
- EXPECT_FALSE(IsStringUTF8("\xf4\x90\x80\x80")); // U+110000
- EXPECT_FALSE(IsStringUTF8("\xf8\xa0\xbf\x80\xbf")); // 5 bytes
- EXPECT_FALSE(IsStringUTF8("\xfc\x9c\xbf\x80\xbf\x80")); // 6 bytes
-
- // BOMs in UTF-16(BE|LE) and UTF-32(BE|LE)
- EXPECT_FALSE(IsStringUTF8("\xfe\xff"));
- EXPECT_FALSE(IsStringUTF8("\xff\xfe"));
- EXPECT_FALSE(IsStringUTF8(std::string("\x00\x00\xfe\xff", 4)));
- EXPECT_FALSE(IsStringUTF8("\xff\xfe\x00\x00"));
-
- // Non-characters : U+xxFFF[EF] where xx is 0x00 through 0x10 and <FDD0,FDEF>
- EXPECT_FALSE(IsStringUTF8("\xef\xbf\xbe")); // U+FFFE)
- EXPECT_FALSE(IsStringUTF8("\xf0\x8f\xbf\xbe")); // U+1FFFE
- EXPECT_FALSE(IsStringUTF8("\xf3\xbf\xbf\xbf")); // U+10FFFF
- EXPECT_FALSE(IsStringUTF8("\xef\xb7\x90")); // U+FDD0
- EXPECT_FALSE(IsStringUTF8("\xef\xb7\xaf")); // U+FDEF
- // Strings in legacy encodings. We can certainly make up strings
- // in a legacy encoding that are valid in UTF-8, but in real data,
- // most of them are invalid as UTF-8.
- EXPECT_FALSE(IsStringUTF8("caf\xe9")); // cafe with U+00E9 in ISO-8859-1
- EXPECT_FALSE(IsStringUTF8("\xb0\xa1\xb0\xa2")); // U+AC00, U+AC001 in EUC-KR
- EXPECT_FALSE(IsStringUTF8("\xa7\x41\xa6\x6e")); // U+4F60 U+597D in Big5
- // "abc" with U+201[CD] in windows-125[0-8]
- EXPECT_FALSE(IsStringUTF8("\x93" "abc\x94"));
- // U+0639 U+064E U+0644 U+064E in ISO-8859-6
- EXPECT_FALSE(IsStringUTF8("\xd9\xee\xe4\xee"));
- // U+03B3 U+03B5 U+03B9 U+03AC in ISO-8859-7
- EXPECT_FALSE(IsStringUTF8("\xe3\xe5\xe9\xdC"));
-
- // Check that we support Embedded Nulls. The first uses the canonical UTF-8
- // representation, and the second uses a 2-byte sequence. The second version
- // is invalid UTF-8 since UTF-8 states that the shortest encoding for a
- // given codepoint must be used.
- static const char kEmbeddedNull[] = "embedded\0null";
- EXPECT_TRUE(IsStringUTF8(
- std::string(kEmbeddedNull, sizeof(kEmbeddedNull))));
- EXPECT_FALSE(IsStringUTF8("embedded\xc0\x80U+0000"));
+ {
+ SCOPED_TRACE("IsStringUTF8AllowingNoncharacters");
+ TestStructurallyValidUtf8(&IsStringUTF8AllowingNoncharacters);
+ TestStructurallyInvalidUtf8(&IsStringUTF8AllowingNoncharacters);
+ TestNoncharacters(&IsStringUTF8AllowingNoncharacters, true);
+ }
}
TEST(StringUtilTest, IsStringASCII) {
@@ -1414,6 +1486,13 @@
WritesCorrectly(2);
WritesCorrectly(5000);
+ // Validate that WriteInto handles 0-length strings
+ std::string empty;
+ const char kOriginal[] = "original";
+ strncpy(WriteInto(&empty, 1), kOriginal, 0);
+ EXPECT_STREQ("", empty.c_str());
+ EXPECT_EQ(0u, empty.size());
+
// Validate that WriteInto doesn't modify other strings
// when using a Copy-on-Write implementation.
const char kLive[] = "live";
diff --git a/base/strings/stringprintf.cc b/base/strings/stringprintf.cc
index 1a08ffb..cc58087 100644
--- a/base/strings/stringprintf.cc
+++ b/base/strings/stringprintf.cc
@@ -39,18 +39,25 @@
va_list argptr) {
return gurl_base::vswprintf(buffer, buf_size, format, argptr);
}
+inline int vsnprintfT(char16_t* buffer,
+ size_t buf_size,
+ const char16_t* format,
+ va_list argptr) {
+ return gurl_base::vswprintf(reinterpret_cast<wchar_t*>(buffer), buf_size,
+ reinterpret_cast<const wchar_t*>(format), argptr);
+}
#endif
// Templatized backend for StringPrintF/StringAppendF. This does not finalize
// the va_list, the caller is expected to do that.
-template <class StringType>
-static void StringAppendVT(StringType* dst,
- const typename StringType::value_type* format,
+template <class CharT>
+static void StringAppendVT(std::basic_string<CharT>* dst,
+ const CharT* format,
va_list ap) {
// First try with a small fixed size buffer.
// This buffer size should be kept in sync with StringUtilTest.GrowBoundary
// and StringUtilTest.StringPrintfBounds.
- typename StringType::value_type stack_buf[1024];
+ CharT stack_buf[1024];
va_list ap_copy;
va_copy(ap_copy, ap);
@@ -93,7 +100,7 @@
return;
}
- std::vector<typename StringType::value_type> mem_buf(mem_length);
+ std::vector<CharT> mem_buf(mem_length);
// NOTE: You can only use a va_list once. Since we're in a while loop, we
// need to make a new copy each time so we don't use up the original.
@@ -129,6 +136,15 @@
va_end(ap);
return result;
}
+
+std::u16string StringPrintf(const char16_t* format, ...) {
+ va_list ap;
+ va_start(ap, format);
+ std::u16string result;
+ StringAppendV(&result, format, ap);
+ va_end(ap);
+ return result;
+}
#endif
std::string StringPrintV(const char* format, va_list ap) {
@@ -156,6 +172,17 @@
va_end(ap);
return *dst;
}
+
+const std::u16string& SStringPrintf(std::u16string* dst,
+ const char16_t* format,
+ ...) {
+ va_list ap;
+ va_start(ap, format);
+ dst->clear();
+ StringAppendV(dst, format, ap);
+ va_end(ap);
+ return *dst;
+}
#endif
void StringAppendF(std::string* dst, const char* format, ...) {
@@ -172,6 +199,13 @@
StringAppendV(dst, format, ap);
va_end(ap);
}
+
+void StringAppendF(std::u16string* dst, const char16_t* format, ...) {
+ va_list ap;
+ va_start(ap, format);
+ StringAppendV(dst, format, ap);
+ va_end(ap);
+}
#endif
void StringAppendV(std::string* dst, const char* format, va_list ap) {
@@ -182,6 +216,10 @@
void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap) {
StringAppendVT(dst, format, ap);
}
+
+void StringAppendV(std::u16string* dst, const char16_t* format, va_list ap) {
+ StringAppendVT(dst, format, ap);
+}
#endif
} // namespace base
diff --git a/base/strings/stringprintf.h b/base/strings/stringprintf.h
index 2abdb68..5768bcc 100644
--- a/base/strings/stringprintf.h
+++ b/base/strings/stringprintf.h
@@ -19,8 +19,14 @@
BASE_EXPORT std::string StringPrintf(const char* format, ...)
PRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
#if defined(OS_WIN)
+// Note: Unfortunately compile time checking of the format string for UTF-16
+// strings is not supported by any compiler, thus these functions should be used
+// carefully and sparingly. Also applies to SStringPrintf and StringAppendV
+// below.
BASE_EXPORT std::wstring StringPrintf(const wchar_t* format, ...)
WPRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
+BASE_EXPORT std::u16string StringPrintf(const char16_t* format, ...)
+ WPRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
#endif
// Return a C++ string given vprintf-like input.
@@ -35,6 +41,9 @@
BASE_EXPORT const std::wstring& SStringPrintf(std::wstring* dst,
const wchar_t* format,
...) WPRINTF_FORMAT(2, 3);
+BASE_EXPORT const std::u16string& SStringPrintf(std::u16string* dst,
+ const char16_t* format,
+ ...) WPRINTF_FORMAT(2, 3);
#endif
// Append result to a supplied string.
@@ -43,6 +52,8 @@
#if defined(OS_WIN)
BASE_EXPORT void StringAppendF(std::wstring* dst, const wchar_t* format, ...)
WPRINTF_FORMAT(2, 3);
+BASE_EXPORT void StringAppendF(std::u16string* dst, const char16_t* format, ...)
+ WPRINTF_FORMAT(2, 3);
#endif
// Lower-level routine that takes a va_list and appends to a specified
@@ -53,6 +64,9 @@
BASE_EXPORT void StringAppendV(std::wstring* dst,
const wchar_t* format,
va_list ap) WPRINTF_FORMAT(2, 0);
+BASE_EXPORT void StringAppendV(std::u16string* dst,
+ const char16_t* format,
+ va_list ap) WPRINTF_FORMAT(2, 0);
#endif
} // namespace base
diff --git a/base/strings/stringprintf_unittest.cc b/base/strings/stringprintf_unittest.cc
index 59e3403..c2e8707 100644
--- a/base/strings/stringprintf_unittest.cc
+++ b/base/strings/stringprintf_unittest.cc
@@ -18,7 +18,10 @@
// A helper for the StringAppendV test that follows.
//
// Just forwards its args to StringAppendV.
-static void StringAppendVTestHelper(std::string* out, const char* format, ...) {
+template <class CharT>
+static void StringAppendVTestHelper(std::basic_string<CharT>* out,
+ const CharT* format,
+ ...) {
va_list ap;
va_start(ap, format);
StringAppendV(out, format, ap);
@@ -35,6 +38,7 @@
EXPECT_EQ("123hello w", StringPrintf("%3d%2s %1c", 123, "hello", 'w'));
#if defined(OS_WIN)
EXPECT_EQ(L"123hello w", StringPrintf(L"%3d%2ls %1lc", 123, L"hello", 'w'));
+ EXPECT_EQ(u"123hello w", StringPrintf(u"%3d%2ls %1lc", 123, u"hello", 'w'));
#endif
}
@@ -47,6 +51,10 @@
std::wstring valuew(L"Hello");
StringAppendF(&valuew, L"%ls", L"");
EXPECT_EQ(L"Hello", valuew);
+
+ std::u16string value16(u"Hello");
+ StringAppendF(&value16, u"%ls", u"");
+ EXPECT_EQ(u"Hello", value16);
#endif
}
@@ -59,6 +67,10 @@
std::wstring valuew(L"Hello");
StringAppendF(&valuew, L" %ls", L"World");
EXPECT_EQ(L"Hello World", valuew);
+
+ std::u16string value16(u"Hello");
+ StringAppendF(&value16, u" %ls", u"World");
+ EXPECT_EQ(u"Hello World", value16);
#endif
}
@@ -71,6 +83,10 @@
std::wstring valuew(L"Hello");
StringAppendF(&valuew, L" %d", 123);
EXPECT_EQ(L"Hello 123", valuew);
+
+ std::u16string value16(u"Hello");
+ StringAppendF(&value16, u" %d", 123);
+ EXPECT_EQ(u"Hello 123", value16);
#endif
}
@@ -79,12 +95,13 @@
TEST(StringPrintfTest, StringPrintfBounds) {
const int kSrcLen = 1026;
char src[kSrcLen];
- for (auto& i : src)
- i = 'A';
+ std::fill_n(src, kSrcLen, 'A');
wchar_t srcw[kSrcLen];
- for (auto& i : srcw)
- i = 'A';
+ std::fill_n(srcw, kSrcLen, 'A');
+
+ char16_t src16[kSrcLen];
+ std::fill_n(src16, kSrcLen, 'A');
for (int i = 1; i < 3; i++) {
src[kSrcLen - i] = 0;
@@ -97,6 +114,14 @@
std::wstring outw;
SStringPrintf(&outw, L"%ls", srcw);
EXPECT_STREQ(srcw, outw.c_str());
+
+ src16[kSrcLen - i] = 0;
+ std::u16string out16;
+ SStringPrintf(&out16, u"%ls", src16);
+ // EXPECT_STREQ does not support const char16_t* strings yet.
+ // Dispatch to the const wchar_t* overload instead.
+ EXPECT_STREQ(reinterpret_cast<const wchar_t*>(src16),
+ reinterpret_cast<const wchar_t*>(out16.c_str()));
#endif
}
}
@@ -129,6 +154,16 @@
std::string out;
StringAppendVTestHelper(&out, "%d foo %s", 1, "bar");
EXPECT_EQ("1 foo bar", out);
+
+#if defined(OS_WIN)
+ std::wstring outw;
+ StringAppendVTestHelper(&outw, L"%d foo %ls", 1, L"bar");
+ EXPECT_EQ(L"1 foo bar", outw);
+
+ std::u16string out16;
+ StringAppendVTestHelper(&out16, u"%d foo %ls", 1, u"bar");
+ EXPECT_EQ(u"1 foo bar", out16);
+#endif
}
// Test the boundary condition for the size of the string_util's
@@ -151,9 +186,6 @@
}
#if defined(OS_WIN)
-// vswprintf in Visual Studio 2013 fails when given U+FFFF. This tests that the
-// failure case is gracefuly handled. In Visual Studio 2015 the bad character
-// is passed through.
TEST(StringPrintfTest, Invalid) {
wchar_t invalid[2];
invalid[0] = 0xffff;
@@ -161,11 +193,7 @@
std::wstring out;
SStringPrintf(&out, L"%ls", invalid);
-#if _MSC_VER >= 1900
EXPECT_STREQ(invalid, out.c_str());
-#else
- EXPECT_STREQ(L"", out.c_str());
-#endif
}
#endif
diff --git a/base/strings/sys_string_conversions.h b/base/strings/sys_string_conversions.h
index 08082ae..7c3c575 100644
--- a/base/strings/sys_string_conversions.h
+++ b/base/strings/sys_string_conversions.h
@@ -31,14 +31,17 @@
// Converts between wide and UTF-8 representations of a string. On error, the
// result is system-dependent.
-BASE_EXPORT std::string SysWideToUTF8(const std::wstring& wide);
-BASE_EXPORT std::wstring SysUTF8ToWide(StringPiece utf8);
+BASE_EXPORT std::string SysWideToUTF8(const std::wstring& wide)
+ WARN_UNUSED_RESULT;
+BASE_EXPORT std::wstring SysUTF8ToWide(StringPiece utf8) WARN_UNUSED_RESULT;
// Converts between wide and the system multi-byte representations of a string.
// DANGER: This will lose information and can change (on Windows, this can
// change between reboots).
-BASE_EXPORT std::string SysWideToNativeMB(const std::wstring& wide);
-BASE_EXPORT std::wstring SysNativeMBToWide(StringPiece native_mb);
+BASE_EXPORT std::string SysWideToNativeMB(const std::wstring& wide)
+ WARN_UNUSED_RESULT;
+BASE_EXPORT std::wstring SysNativeMBToWide(StringPiece native_mb)
+ WARN_UNUSED_RESULT;
// Windows-specific ------------------------------------------------------------
@@ -47,9 +50,11 @@
// Converts between 8-bit and wide strings, using the given code page. The
// code page identifier is one accepted by the Windows function
// MultiByteToWideChar().
-BASE_EXPORT std::wstring SysMultiByteToWide(StringPiece mb, uint32_t code_page);
+BASE_EXPORT std::wstring SysMultiByteToWide(StringPiece mb, uint32_t code_page)
+ WARN_UNUSED_RESULT;
BASE_EXPORT std::string SysWideToMultiByte(const std::wstring& wide,
- uint32_t code_page);
+ uint32_t code_page)
+ WARN_UNUSED_RESULT;
#endif // defined(OS_WIN)
@@ -61,21 +66,25 @@
// 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 CFStringRef SysUTF16ToCFStringRef(StringPiece16 utf16);
+BASE_EXPORT CFStringRef SysUTF8ToCFStringRef(StringPiece utf8)
+ WARN_UNUSED_RESULT;
+BASE_EXPORT CFStringRef SysUTF16ToCFStringRef(StringPiece16 utf16)
+ WARN_UNUSED_RESULT;
// Same, but returns an autoreleased NSString.
-BASE_EXPORT NSString* SysUTF8ToNSString(StringPiece utf8);
-BASE_EXPORT NSString* SysUTF16ToNSString(StringPiece16 utf16);
+BASE_EXPORT NSString* SysUTF8ToNSString(StringPiece utf8) WARN_UNUSED_RESULT;
+BASE_EXPORT NSString* SysUTF16ToNSString(StringPiece16 utf16)
+ WARN_UNUSED_RESULT;
// Converts a CFStringRef to an STL string. Returns an empty string on failure.
-BASE_EXPORT std::string SysCFStringRefToUTF8(CFStringRef ref);
-BASE_EXPORT string16 SysCFStringRefToUTF16(CFStringRef ref);
+BASE_EXPORT std::string SysCFStringRefToUTF8(CFStringRef ref)
+ WARN_UNUSED_RESULT;
+BASE_EXPORT string16 SysCFStringRefToUTF16(CFStringRef ref) WARN_UNUSED_RESULT;
// Same, but accepts NSString input. Converts nil NSString* to the appropriate
// string type of length 0.
-BASE_EXPORT std::string SysNSStringToUTF8(NSString* ref);
-BASE_EXPORT string16 SysNSStringToUTF16(NSString* ref);
+BASE_EXPORT std::string SysNSStringToUTF8(NSString* ref) WARN_UNUSED_RESULT;
+BASE_EXPORT string16 SysNSStringToUTF16(NSString* ref) WARN_UNUSED_RESULT;
#endif // defined(OS_MACOSX)
diff --git a/base/strings/utf_offset_string_conversions.cc b/base/strings/utf_offset_string_conversions.cc
index 5bf7967..7d00bb4 100644
--- a/base/strings/utf_offset_string_conversions.cc
+++ b/base/strings/utf_offset_string_conversions.cc
@@ -90,16 +90,22 @@
auto adjusted_iter = adjustments_on_adjusted_string->begin();
auto first_iter = first_adjustments.begin();
// Simultaneously iterate over all |adjustments_on_adjusted_string| and
- // |first_adjustments|, adding adjustments to or correcting the adjustments
- // in |adjustments_on_adjusted_string| as we go. |shift| keeps track of the
- // current number of characters collapsed by |first_adjustments| up to this
- // point. |currently_collapsing| keeps track of the number of characters
- // collapsed by |first_adjustments| into the current |adjusted_iter|'s
- // length. These are characters that will change |shift| as soon as we're
- // done processing the current |adjusted_iter|; they are not yet reflected in
- // |shift|.
+ // |first_adjustments|, pushing adjustments at the end of
+ // |adjustments_builder| as we go. |shift| keeps track of the current number
+ // of characters collapsed by |first_adjustments| up to this point.
+ // |currently_collapsing| keeps track of the number of characters collapsed by
+ // |first_adjustments| into the current |adjusted_iter|'s length. These are
+ // characters that will change |shift| as soon as we're done processing the
+ // current |adjusted_iter|; they are not yet reflected in |shift|.
size_t shift = 0;
size_t currently_collapsing = 0;
+ // While we *could* update |adjustments_on_adjusted_string| in place by
+ // inserting new adjustments into the middle, we would be repeatedly calling
+ // |std::vector::insert|. That would cost O(n) time per insert, relative to
+ // distance from end of the string. By instead allocating
+ // |adjustments_builder| and calling |std::vector::push_back|, we only pay
+ // amortized constant time per push. We are trading space for time.
+ Adjustments adjustments_builder;
while (adjusted_iter != adjustments_on_adjusted_string->end()) {
if ((first_iter == first_adjustments.end()) ||
((adjusted_iter->original_offset + shift +
@@ -112,6 +118,7 @@
adjusted_iter->original_offset += shift;
shift += currently_collapsing;
currently_collapsing = 0;
+ adjustments_builder.push_back(*adjusted_iter);
++adjusted_iter;
} else if ((adjusted_iter->original_offset + shift) >
first_iter->original_offset) {
@@ -127,15 +134,9 @@
GURL_DCHECK_LE(first_iter->original_offset + first_iter->output_length,
adjusted_iter->original_offset + shift);
- // Add the |first_adjustment_iter| to the full set of adjustments while
- // making sure |adjusted_iter| continues pointing to the same element.
- // We do this by inserting the |first_adjustment_iter| right before
- // |adjusted_iter|, then incrementing |adjusted_iter| so it points to
- // the following element.
+ // Add the |first_iter| to the full set of adjustments.
shift += first_iter->original_length - first_iter->output_length;
- adjusted_iter = adjustments_on_adjusted_string->insert(
- adjusted_iter, *first_iter);
- ++adjusted_iter;
+ adjustments_builder.push_back(*first_iter);
++first_iter;
} else {
// The first adjustment adjusted something that then got further adjusted
@@ -168,10 +169,10 @@
// (Their offsets are already correct with respect to the original string.)
// Append them all.
GURL_DCHECK(adjusted_iter == adjustments_on_adjusted_string->end());
- adjustments_on_adjusted_string->insert(
- adjustments_on_adjusted_string->end(), first_iter,
- first_adjustments.end());
+ adjustments_builder.insert(adjustments_builder.end(), first_iter,
+ first_adjustments.end());
}
+ *adjustments_on_adjusted_string = std::move(adjustments_builder);
}
// Converts the given source Unicode character type to the given destination
diff --git a/base/strings/utf_offset_string_conversions.h b/base/strings/utf_offset_string_conversions.h
index 8902ee5..c2e2ba7 100644
--- a/base/strings/utf_offset_string_conversions.h
+++ b/base/strings/utf_offset_string_conversions.h
@@ -98,7 +98,7 @@
gurl_base::OffsetAdjuster::Adjustments* adjustments);
BASE_EXPORT string16 UTF8ToUTF16WithAdjustments(
const gurl_base::StringPiece& utf8,
- gurl_base::OffsetAdjuster::Adjustments* adjustments);
+ gurl_base::OffsetAdjuster::Adjustments* adjustments) WARN_UNUSED_RESULT;
// As above, but instead internally examines the adjustments and applies them
// to |offsets_for_adjustment|. Input offsets greater than the length of the
// input string will be set to string16::npos. See comments by AdjustOffsets().
diff --git a/base/strings/utf_string_conversion_utils.h b/base/strings/utf_string_conversion_utils.h
index 84d18f7..075832e 100644
--- a/base/strings/utf_string_conversion_utils.h
+++ b/base/strings/utf_string_conversion_utils.h
@@ -17,16 +17,19 @@
namespace gurl_base {
inline bool IsValidCodepoint(uint32_t code_point) {
- // Excludes the surrogate code points ([0xD800, 0xDFFF]) and
- // codepoints larger than 0x10FFFF (the highest codepoint allowed).
- // Non-characters and unassigned codepoints are allowed.
+ // Excludes code points that are not Unicode scalar values, i.e.
+ // surrogate code points ([0xD800, 0xDFFF]). Additionally, excludes
+ // code points larger than 0x10FFFF (the highest codepoint allowed).
+ // Non-characters and unassigned code points are allowed.
+ // https://unicode.org/glossary/#unicode_scalar_value
return code_point < 0xD800u ||
(code_point >= 0xE000u && code_point <= 0x10FFFFu);
}
inline bool IsValidCharacter(uint32_t code_point) {
- // Excludes non-characters (U+FDD0..U+FDEF, and all codepoints ending in
- // 0xFFFE or 0xFFFF) from the set of valid code points.
+ // Excludes non-characters (U+FDD0..U+FDEF, and all code points
+ // ending in 0xFFFE or 0xFFFF) from the set of valid code points.
+ // https://unicode.org/faq/private_use.html#nonchar1
return code_point < 0xD800u || (code_point >= 0xE000u &&
code_point < 0xFDD0u) || (code_point > 0xFDEFu &&
code_point <= 0x10FFFFu && (code_point & 0xFFFEu) != 0xFFFEu);
diff --git a/base/strings/utf_string_conversions.h b/base/strings/utf_string_conversions.h
index e64f420..745372c 100644
--- a/base/strings/utf_string_conversions.h
+++ b/base/strings/utf_string_conversions.h
@@ -23,31 +23,31 @@
// possible.
BASE_EXPORT bool WideToUTF8(const wchar_t* src, size_t src_len,
std::string* output);
-BASE_EXPORT std::string WideToUTF8(WStringPiece wide);
+BASE_EXPORT std::string WideToUTF8(WStringPiece wide) WARN_UNUSED_RESULT;
BASE_EXPORT bool UTF8ToWide(const char* src, size_t src_len,
std::wstring* output);
-BASE_EXPORT std::wstring UTF8ToWide(StringPiece utf8);
+BASE_EXPORT std::wstring UTF8ToWide(StringPiece utf8) WARN_UNUSED_RESULT;
BASE_EXPORT bool WideToUTF16(const wchar_t* src, size_t src_len,
string16* output);
-BASE_EXPORT string16 WideToUTF16(WStringPiece wide);
+BASE_EXPORT string16 WideToUTF16(WStringPiece wide) WARN_UNUSED_RESULT;
BASE_EXPORT bool UTF16ToWide(const char16* src, size_t src_len,
std::wstring* output);
-BASE_EXPORT std::wstring UTF16ToWide(StringPiece16 utf16);
+BASE_EXPORT std::wstring UTF16ToWide(StringPiece16 utf16) WARN_UNUSED_RESULT;
BASE_EXPORT bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);
-BASE_EXPORT string16 UTF8ToUTF16(StringPiece utf8);
+BASE_EXPORT string16 UTF8ToUTF16(StringPiece utf8) WARN_UNUSED_RESULT;
BASE_EXPORT bool UTF16ToUTF8(const char16* src, size_t src_len,
std::string* output);
-BASE_EXPORT std::string UTF16ToUTF8(StringPiece16 utf16);
+BASE_EXPORT std::string UTF16ToUTF8(StringPiece16 utf16) WARN_UNUSED_RESULT;
// This converts an ASCII string, typically a hardcoded constant, to a UTF16
// string.
-BASE_EXPORT string16 ASCIIToUTF16(StringPiece ascii);
+BASE_EXPORT string16 ASCIIToUTF16(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 UTF16ToASCII(StringPiece16 utf16);
+BASE_EXPORT std::string UTF16ToASCII(StringPiece16 utf16) WARN_UNUSED_RESULT;
} // namespace base
diff --git a/base/strings/utf_string_conversions_fuzzer.cc b/base/strings/utf_string_conversions_fuzzer.cc
index 96bccda..55e75f7 100644
--- a/base/strings/utf_string_conversions_fuzzer.cc
+++ b/base/strings/utf_string_conversions_fuzzer.cc
@@ -2,6 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "base/macros.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
@@ -14,10 +15,10 @@
gurl_base::StringPiece string_piece_input(reinterpret_cast<const char*>(data),
size);
- gurl_base::UTF8ToWide(string_piece_input);
+ ignore_result(gurl_base::UTF8ToWide(string_piece_input));
gurl_base::UTF8ToWide(reinterpret_cast<const char*>(data), size,
&output_std_wstring);
- gurl_base::UTF8ToUTF16(string_piece_input);
+ ignore_result(gurl_base::UTF8ToUTF16(string_piece_input));
gurl_base::UTF8ToUTF16(reinterpret_cast<const char*>(data), size,
&output_string16);
@@ -25,10 +26,10 @@
if (size % 2 == 0) {
gurl_base::StringPiece16 string_piece_input16(
reinterpret_cast<const gurl_base::char16*>(data), size / 2);
- gurl_base::UTF16ToWide(output_string16);
+ ignore_result(gurl_base::UTF16ToWide(output_string16));
gurl_base::UTF16ToWide(reinterpret_cast<const gurl_base::char16*>(data), size / 2,
&output_std_wstring);
- gurl_base::UTF16ToUTF8(string_piece_input16);
+ ignore_result(gurl_base::UTF16ToUTF8(string_piece_input16));
gurl_base::UTF16ToUTF8(reinterpret_cast<const gurl_base::char16*>(data), size / 2,
&output_std_string);
}
@@ -36,10 +37,10 @@
// Test for wchar_t.
size_t wchar_t_size = sizeof(wchar_t);
if (size % wchar_t_size == 0) {
- gurl_base::WideToUTF8(output_std_wstring);
+ ignore_result(gurl_base::WideToUTF8(output_std_wstring));
gurl_base::WideToUTF8(reinterpret_cast<const wchar_t*>(data),
size / wchar_t_size, &output_std_string);
- gurl_base::WideToUTF16(output_std_wstring);
+ ignore_result(gurl_base::WideToUTF16(output_std_wstring));
gurl_base::WideToUTF16(reinterpret_cast<const wchar_t*>(data),
size / wchar_t_size, &output_string16);
}
@@ -49,7 +50,7 @@
if (gurl_base::IsStringASCII(string_piece_input)) {
output_string16 = gurl_base::ASCIIToUTF16(string_piece_input);
gurl_base::StringPiece16 string_piece_input16(output_string16);
- gurl_base::UTF16ToASCII(string_piece_input16);
+ ignore_result(gurl_base::UTF16ToASCII(string_piece_input16));
}
return 0;
diff --git a/build/build_config.h b/build/build_config.h
index 0d87d80..688b779 100644
--- a/build/build_config.h
+++ b/build/build_config.h
@@ -63,7 +63,7 @@
#define OS_QNX 1
#elif defined(_AIX)
#define OS_AIX 1
-#elif defined(__asmjs__)
+#elif defined(__asmjs__) || defined(__wasm__)
#define OS_ASMJS
#else
#error Please add support for your platform in build/build_config.h
@@ -139,7 +139,7 @@
#define ARCH_CPU_ARM64 1
#define ARCH_CPU_64_BITS 1
#define ARCH_CPU_LITTLE_ENDIAN 1
-#elif defined(__pnacl__) || defined(__asmjs__)
+#elif defined(__pnacl__) || defined(__asmjs__) || defined(__wasm__)
#define ARCH_CPU_32_BITS 1
#define ARCH_CPU_LITTLE_ENDIAN 1
#elif defined(__MIPSEL__)
diff --git a/polyfills/base/logging.h b/polyfills/base/logging.h
index def1745..41ddacd 100644
--- a/polyfills/base/logging.h
+++ b/polyfills/base/logging.h
@@ -24,10 +24,12 @@
#define GURL_CHECK_NE(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})
#define GURL_DCHECK_GT(statement, statement2) GurlFakeLogSink({statement, statement2})
#define GURL_DCHECK_IS_ON() false
#define GURL_DCHECK_LE(statement, statement2) GurlFakeLogSink({statement, statement2})
#define GURL_DCHECK_LT(statement, statement2) GurlFakeLogSink({statement, statement2})
+#define GURL_DCHECK_NE(statement, statement2) GurlFakeLogSink({statement, statement2})
#define GURL_DCHECK(statement) GurlFakeLogSink({statement})
#define GURL_DLOG(severity) GurlFakeLogSink(true)
#define GURL_LOG(severity) GurlFakeLogSink(true)
diff --git a/url/gurl.cc b/url/gurl.cc
index c8e424f..36c5ee2 100644
--- a/url/gurl.cc
+++ b/url/gurl.cc
@@ -396,14 +396,14 @@
return ComponentString(file_component);
}
-std::string GURL::PathForRequest() const {
+gurl_base::StringPiece GURL::PathForRequestPiece() const {
GURL_DCHECK(parsed_.path.len > 0)
<< "Canonical path for requests should be non-empty";
if (parsed_.ref.len >= 0) {
// Clip off the reference when it exists. The reference starts after the
// #-sign, so we have to subtract one to also remove it.
- return std::string(spec_, parsed_.path.begin,
- parsed_.ref.begin - parsed_.path.begin - 1);
+ return gurl_base::StringPiece(&spec_[parsed_.path.begin],
+ parsed_.ref.begin - parsed_.path.begin - 1);
}
// Compute the actual path length, rather than depending on the spec's
// terminator. If we're an inner_url, our spec continues on into our outer
@@ -412,7 +412,11 @@
if (parsed_.query.is_valid())
path_len = parsed_.query.end() - parsed_.path.begin;
- return std::string(spec_, parsed_.path.begin, path_len);
+ return gurl_base::StringPiece(&spec_[parsed_.path.begin], path_len);
+}
+
+std::string GURL::PathForRequest() const {
+ return PathForRequestPiece().as_string();
}
std::string GURL::HostNoBrackets() const {
diff --git a/url/gurl.h b/url/gurl.h
index 8c026f7..73d2b43 100644
--- a/url/gurl.h
+++ b/url/gurl.h
@@ -386,6 +386,9 @@
// parameter, and query portions of the URL. It is guaranteed to be ASCII.
std::string PathForRequest() const;
+ // Returns the same characters as PathForRequest(), avoiding a copy.
+ gurl_base::StringPiece PathForRequestPiece() const;
+
// Returns the host, excluding the square brackets surrounding IPv6 address
// literals. This can be useful for passing to getaddrinfo().
std::string HostNoBrackets() const;
diff --git a/url/gurl_unittest.cc b/url/gurl_unittest.cc
index 0375eae..b114920 100644
--- a/url/gurl_unittest.cc
+++ b/url/gurl_unittest.cc
@@ -289,21 +289,42 @@
bool expected_valid;
const char* expected;
} resolve_cases[] = {
- {"http://www.google.com/", "foo.html", true, "http://www.google.com/foo.html"},
- {"http://www.google.com/foo/", "bar", true, "http://www.google.com/foo/bar"},
- {"http://www.google.com/foo/", "/bar", true, "http://www.google.com/bar"},
- {"http://www.google.com/foo", "bar", true, "http://www.google.com/bar"},
- {"http://www.google.com/", "http://images.google.com/foo.html", true, "http://images.google.com/foo.html"},
- {"http://www.google.com/", "http://images.\tgoogle.\ncom/\rfoo.html", true, "http://images.google.com/foo.html"},
- {"http://www.google.com/blah/bloo?c#d", "../../../hello/./world.html?a#b", true, "http://www.google.com/hello/world.html?a#b"},
- {"http://www.google.com/foo#bar", "#com", true, "http://www.google.com/foo#com"},
- {"http://www.google.com/", "Https:images.google.com", true, "https://images.google.com/"},
+ {"http://www.google.com/", "foo.html", true,
+ "http://www.google.com/foo.html"},
+ {"http://www.google.com/foo/", "bar", true,
+ "http://www.google.com/foo/bar"},
+ {"http://www.google.com/foo/", "/bar", true, "http://www.google.com/bar"},
+ {"http://www.google.com/foo", "bar", true, "http://www.google.com/bar"},
+ {"http://www.google.com/", "http://images.google.com/foo.html", true,
+ "http://images.google.com/foo.html"},
+ {"http://www.google.com/", "http://images.\tgoogle.\ncom/\rfoo.html",
+ true, "http://images.google.com/foo.html"},
+ {"http://www.google.com/blah/bloo?c#d", "../../../hello/./world.html?a#b",
+ true, "http://www.google.com/hello/world.html?a#b"},
+ {"http://www.google.com/foo#bar", "#com", true,
+ "http://www.google.com/foo#com"},
+ {"http://www.google.com/", "Https:images.google.com", true,
+ "https://images.google.com/"},
// A non-standard base can be replaced with a standard absolute URL.
- {"data:blahblah", "http://google.com/", true, "http://google.com/"},
- {"data:blahblah", "http:google.com", true, "http://google.com/"},
+ {"data:blahblah", "http://google.com/", true, "http://google.com/"},
+ {"data:blahblah", "http:google.com", true, "http://google.com/"},
// Filesystem URLs have different paths to test.
- {"filesystem:http://www.google.com/type/", "foo.html", true, "filesystem:http://www.google.com/type/foo.html"},
- {"filesystem:http://www.google.com/type/", "../foo.html", true, "filesystem:http://www.google.com/type/foo.html"},
+ {"filesystem:http://www.google.com/type/", "foo.html", true,
+ "filesystem:http://www.google.com/type/foo.html"},
+ {"filesystem:http://www.google.com/type/", "../foo.html", true,
+ "filesystem:http://www.google.com/type/foo.html"},
+ // https://crbug.com/530123 - scheme validation (e.g. are "10.0.0.7:"
+ // or "x1:" valid schemes) when deciding if |relative| is an absolute url.
+ {"file:///some/dir/ip-relative.html", "10.0.0.7:8080/foo.html", true,
+ "file:///some/dir/10.0.0.7:8080/foo.html"},
+ {"file:///some/dir/", "1://host", true, "file:///some/dir/1://host"},
+ {"file:///some/dir/", "x1://host", true, "x1://host"},
+ {"file:///some/dir/", "X1://host", true, "x1://host"},
+ {"file:///some/dir/", "x.://host", true, "x.://host"},
+ {"file:///some/dir/", "x+://host", true, "x+://host"},
+ {"file:///some/dir/", "x-://host", true, "x-://host"},
+ {"file:///some/dir/", "x!://host", true, "file:///some/dir/x!://host"},
+ {"file:///some/dir/", "://host", true, "file:///some/dir/://host"},
};
for (size_t i = 0; i < gurl_base::size(resolve_cases); i++) {
@@ -539,11 +560,14 @@
for (size_t i = 0; i < gurl_base::size(cases); i++) {
GURL url(cases[i].input);
- std::string path_request = url.PathForRequest();
- EXPECT_EQ(cases[i].expected, path_request);
+ EXPECT_EQ(cases[i].expected, url.PathForRequest());
+ EXPECT_EQ(cases[i].expected, url.PathForRequestPiece());
EXPECT_EQ(cases[i].inner_expected == NULL, url.inner_url() == NULL);
- if (url.inner_url() && cases[i].inner_expected)
+ if (url.inner_url() && cases[i].inner_expected) {
EXPECT_EQ(cases[i].inner_expected, url.inner_url()->PathForRequest());
+ EXPECT_EQ(cases[i].inner_expected,
+ url.inner_url()->PathForRequestPiece());
+ }
}
}
@@ -567,11 +591,6 @@
{"ftp://www.google.com:21/", 21},
{"ftp://www.google.com:80/", 80},
- // gopher
- {"gopher://www.google.com/", 70},
- {"gopher://www.google.com:70/", 70},
- {"gopher://www.google.com:80/", 80},
-
// file - no port
{"file://www.google.com/", PORT_UNSPECIFIED},
{"file://www.google.com:443/", PORT_UNSPECIFIED},
diff --git a/url/origin.cc b/url/origin.cc
index 6eda15e..16e93b0 100644
--- a/url/origin.cc
+++ b/url/origin.cc
@@ -7,8 +7,12 @@
#include <stdint.h>
#include <algorithm>
+#include <vector>
+#include "base/base64.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"
#include "base/strings/string_number_conversions.h"
@@ -42,12 +46,12 @@
// It's SchemeHostPort's responsibility to filter out unrecognized schemes;
// sanity check that this is happening.
- GURL_DCHECK(tuple.IsInvalid() || url.IsStandard() ||
+ GURL_DCHECK(!tuple.IsValid() || url.IsStandard() ||
gurl_base::Contains(GetLocalSchemes(), url.scheme_piece()) ||
AllowNonStandardSchemesForAndroidWebView());
}
- if (tuple.IsInvalid())
+ if (!tuple.IsValid())
return Origin();
return Origin(std::move(tuple));
}
@@ -74,7 +78,7 @@
uint16_t port) {
SchemeHostPort tuple(scheme.as_string(), host.as_string(), port,
SchemeHostPort::CHECK_CANONICALIZATION);
- if (tuple.IsInvalid())
+ if (!tuple.IsValid())
return gurl_base::nullopt;
return Origin(std::move(tuple));
}
@@ -91,7 +95,7 @@
// For opaque origins, it is okay for the SchemeHostPort to be invalid;
// however, this should only arise when the arguments indicate the
// canonical representation of the invalid SchemeHostPort.
- if (precursor.IsInvalid() &&
+ if (!precursor.IsValid() &&
!(precursor_scheme.empty() && precursor_host.empty() &&
precursor_port == 0)) {
return gurl_base::nullopt;
@@ -105,7 +109,7 @@
uint16_t port) {
SchemeHostPort tuple(std::move(scheme), std::move(host), port,
SchemeHostPort::ALREADY_CANONICALIZED);
- if (tuple.IsInvalid())
+ if (!tuple.IsValid())
return Origin();
return Origin(std::move(tuple));
}
@@ -171,7 +175,7 @@
// And if it is unique opaque origin, it definitely is fine. But if there
// is a precursor stored, we should fall through to compare the tuples.
- if (tuple_.IsInvalid())
+ if (!tuple_.IsValid())
return true;
}
@@ -198,7 +202,7 @@
// opaque origin. It is valid case, as any browser-initiated navigation
// to about:blank or data: URL will result in a document with such
// origin and it is valid for it to create blob: URLs.
- if (tuple_.IsInvalid())
+ if (!tuple_.IsValid())
return true;
url_tuple = SchemeHostPort(GURL(url.GetContent()));
@@ -221,7 +225,7 @@
// If |this| does not have valid precursor tuple, it is unique opaque origin,
// which is what we expect non-standard schemes to get.
- if (tuple_.IsInvalid())
+ if (!tuple_.IsValid())
return true;
// However, when there is precursor present, the schemes must match.
@@ -257,7 +261,7 @@
: nonce_->raw_token().ToString();
std::string out = gurl_base::StrCat({Serialize(), " [internally: (", nonce, ")"});
- if (tuple_.IsInvalid())
+ if (!tuple_.IsValid())
gurl_base::StrAppend(&out, {" anonymous]"});
else
gurl_base::StrAppend(&out, {" derived from ", tuple_.Serialize(), "]"});
@@ -266,7 +270,7 @@
Origin::Origin(SchemeHostPort tuple) : tuple_(std::move(tuple)) {
GURL_DCHECK(!opaque());
- GURL_DCHECK(!tuple_.IsInvalid());
+ GURL_DCHECK(tuple_.IsValid());
}
// Constructs an opaque origin derived from |precursor|.
@@ -279,6 +283,82 @@
GURL_DCHECK_EQ(0U, port());
}
+// The pickle is saved in the following format, in order:
+// string - tuple_.GetURL().spec().
+// uint64_t (if opaque) - high bits of nonce if opaque. 0 if not initialized.
+// uint64_t (if opaque) - low bits of nonce if opaque. 0 if not initialized.
+gurl_base::Optional<std::string> Origin::SerializeWithNonce() const {
+ if (!opaque() && !tuple_.IsValid())
+ return gurl_base::nullopt;
+
+ gurl_base::Pickle pickle;
+ pickle.WriteString(tuple_.Serialize());
+ if (opaque() && !nonce_->raw_token().is_empty()) {
+ pickle.WriteUInt64(nonce_->token().GetHighForSerialization());
+ pickle.WriteUInt64(nonce_->token().GetLowForSerialization());
+ } else if (opaque()) {
+ // Nonce hasn't been initialized.
+ pickle.WriteUInt64(0);
+ pickle.WriteUInt64(0);
+ }
+
+ gurl_base::span<const uint8_t> data(
+ static_cast<const uint8_t*>(pickle.data()),
+ static_cast<const uint8_t*>(pickle.data()) + pickle.size());
+ // Base64 encode the data to make it nicer to play with.
+ return gurl_base::Base64Encode(data);
+}
+
+// static
+gurl_base::Optional<Origin> Origin::Deserialize(const std::string& value) {
+ std::string data;
+ if (!gurl_base::Base64Decode(value, &data))
+ return gurl_base::nullopt;
+ gurl_base::Pickle pickle(reinterpret_cast<char*>(&data[0]), data.size());
+ gurl_base::PickleIterator reader(pickle);
+
+ std::string pickled_url;
+ if (!reader.ReadString(&pickled_url))
+ return gurl_base::nullopt;
+ GURL url(pickled_url);
+
+ // If only a tuple was serialized, then this origin is not opaque. For opaque
+ // origins, we expect two uint64's to be left in the pickle.
+ bool is_opaque = !reader.ReachedEnd();
+
+ // Opaque origins without a tuple are ok.
+ if (!is_opaque && !url.is_valid())
+ return gurl_base::nullopt;
+ SchemeHostPort tuple(url);
+
+ // Possible successful early return if the pickled Origin was not opaque.
+ if (!is_opaque) {
+ Origin origin(tuple);
+ if (origin.opaque())
+ return gurl_base::nullopt; // Something went horribly wrong.
+ return origin;
+ }
+
+ uint64_t nonce_high = 0;
+ if (!reader.ReadUInt64(&nonce_high))
+ return gurl_base::nullopt;
+
+ uint64_t nonce_low = 0;
+ if (!reader.ReadUInt64(&nonce_low))
+ return gurl_base::nullopt;
+
+ Origin::Nonce nonce;
+ if (nonce_high != 0 && nonce_low != 0) {
+ // The serialized nonce wasn't empty, so copy it here.
+ nonce = Origin::Nonce(
+ gurl_base::UnguessableToken::Deserialize(nonce_high, nonce_low));
+ }
+ Origin origin;
+ origin.nonce_ = std::move(nonce);
+ origin.tuple_ = tuple;
+ return origin;
+}
+
std::ostream& operator<<(std::ostream& out, const url::Origin& origin) {
out << origin.GetDebugString();
return out;
@@ -351,4 +431,17 @@
return !(*this == other);
}
+namespace debug {
+
+ScopedOriginCrashKey::ScopedOriginCrashKey(
+ gurl_base::debug::CrashKeyString* crash_key,
+ const url::Origin* value)
+ : gurl_base::debug::ScopedCrashKeyString(
+ crash_key,
+ value ? value->GetDebugString() : "nullptr") {}
+
+ScopedOriginCrashKey::~ScopedOriginCrashKey() = default;
+
+} // namespace debug
+
} // namespace url
diff --git a/url/origin.h b/url/origin.h
index 58c9221..351c482 100644
--- a/url/origin.h
+++ b/url/origin.h
@@ -7,21 +7,37 @@
#include <stdint.h>
+#include <memory>
#include <string>
#include "polyfills/base/component_export.h"
#include "polyfills/base/debug/alias.h"
+#include "base/debug/crash_logging.h"
#include "base/optional.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/unguessable_token.h"
+#include "build/build_config.h"
#include "ipc/ipc_param_traits.h"
#include "url/scheme_host_port.h"
#include "url/third_party/mozilla/url_parse.h"
#include "url/url_canon.h"
#include "url/url_constants.h"
+#if defined(OS_ANDROID)
+#include <jni.h>
+
+namespace gurl_base {
+namespace android {
+template <typename>
+class ScopedJavaLocalRef;
+template <typename>
+class JavaRef;
+} // namespace android
+} // namespace base
+#endif // OS_ANDROID
+
class GURL;
namespace blink {
@@ -39,6 +55,11 @@
struct UrlOriginAdapter;
} // namespace mojo
+namespace net {
+class NetworkIsolationKey;
+class OpaqueNonTransientNetworkIsolationKeyTest;
+} // namespace net
+
namespace url {
namespace mojom {
@@ -130,6 +151,9 @@
// 2. 'filesystem' URLs behave as 'blob' URLs (that is, the origin is parsed
// out of everything in the URL which follows the scheme).
// 3. 'file' URLs all parse as ("file", "", 0).
+ //
+ // Note that the returned Origin may have a different scheme and host from
+ // |url| (e.g. in case of blob URLs - see OriginTest.ConstructFromGURL).
static Origin Create(const GURL& url);
// Creates an Origin for the resource |url| as if it were requested
@@ -266,8 +290,16 @@
// and precursor information.
std::string GetDebugString() const;
+#if defined(OS_ANDROID)
+ gurl_base::android::ScopedJavaLocalRef<jobject> CreateJavaObject() const;
+ static Origin FromJavaObject(
+ const gurl_base::android::JavaRef<jobject>& java_origin);
+#endif // OS_ANDROID
+
private:
friend class blink::SecurityOrigin;
+ friend class net::NetworkIsolationKey;
+ friend class net::OpaqueNonTransientNetworkIsolationKeyTest;
friend class OriginTest;
friend struct mojo::UrlOriginAdapter;
friend struct ipc_fuzzer::FuzzTraits<Origin>;
@@ -362,6 +394,16 @@
// used only when trying to send an Origin across an IPC pipe.
gurl_base::Optional<gurl_base::UnguessableToken> GetNonceForSerialization() const;
+ // Serializes this Origin, including its nonce if it is opaque. If an opaque
+ // origin's |tuple_| is invalid or the nonce isn't initialized, nullopt is
+ // returned. Use of this method should be limited as an opaque origin will
+ // never be matchable in future browser sessions.
+ gurl_base::Optional<std::string> SerializeWithNonce() const;
+
+ // Deserializes an origin from |ToValueWithNonce|. Returns nullopt if the
+ // value was invalid in any way.
+ static gurl_base::Optional<Origin> Deserialize(const std::string& value);
+
// The tuple is used for both tuple origins (e.g. https://example.com:80), as
// well as for opaque origins, where it tracks the tuple origin from which
// the opaque origin was initially derived (we call this the "precursor"
@@ -388,6 +430,21 @@
#define DEBUG_ALIAS_FOR_ORIGIN(var_name, origin) \
DEBUG_ALIAS_FOR_CSTR(var_name, (origin).Serialize().c_str(), 128)
+namespace debug {
+
+class COMPONENT_EXPORT(URL) ScopedOriginCrashKey
+ : public gurl_base::debug::ScopedCrashKeyString {
+ public:
+ ScopedOriginCrashKey(gurl_base::debug::CrashKeyString* crash_key,
+ const url::Origin* value);
+ ~ScopedOriginCrashKey();
+
+ ScopedOriginCrashKey(const ScopedOriginCrashKey&) = delete;
+ ScopedOriginCrashKey& operator=(const ScopedOriginCrashKey&) = delete;
+};
+
+} // namespace debug
+
} // namespace url
#endif // URL_ORIGIN_H_
diff --git a/url/origin_unittest.cc b/url/origin_unittest.cc
index 2754f23..514169b 100644
--- a/url/origin_unittest.cc
+++ b/url/origin_unittest.cc
@@ -55,7 +55,6 @@
AddStandardScheme("standard-but-noaccess", SchemeType::SCHEME_WITH_HOST);
AddNoAccessScheme("standard-but-noaccess");
}
- void TearDown() override { url::ResetForTests(); }
::testing::AssertionResult DoEqualityComparisons(const url::Origin& a,
const url::Origin& b,
@@ -96,7 +95,8 @@
return origin.GetNonceForSerialization();
}
- // Wrapper around url::Origin method to expose it to tests.
+ // Wrappers around url::Origin methods to expose it to tests.
+
gurl_base::Optional<Origin> UnsafelyCreateOpaqueOriginWithoutNormalization(
gurl_base::StringPiece precursor_scheme,
gurl_base::StringPiece precursor_host,
@@ -105,6 +105,17 @@
return Origin::UnsafelyCreateOpaqueOriginWithoutNormalization(
precursor_scheme, precursor_host, precursor_port, nonce);
}
+
+ gurl_base::Optional<std::string> SerializeWithNonce(const Origin& origin) {
+ return origin.SerializeWithNonce();
+ }
+
+ gurl_base::Optional<Origin> Deserialize(const std::string& value) {
+ return Origin::Deserialize(value);
+ }
+
+ private:
+ ScopedSchemeRegistryForTests scoped_registry_;
};
TEST_F(OriginTest, OpaqueOriginComparison) {
@@ -116,14 +127,14 @@
EXPECT_EQ("", opaque_a.host());
EXPECT_EQ(0, opaque_a.port());
EXPECT_EQ(SchemeHostPort(), opaque_a.GetTupleOrPrecursorTupleIfOpaque());
- EXPECT_TRUE(opaque_a.GetTupleOrPrecursorTupleIfOpaque().IsInvalid());
+ EXPECT_FALSE(opaque_a.GetTupleOrPrecursorTupleIfOpaque().IsValid());
EXPECT_TRUE(opaque_b.opaque());
EXPECT_EQ("", opaque_b.scheme());
EXPECT_EQ("", opaque_b.host());
EXPECT_EQ(0, opaque_b.port());
EXPECT_EQ(SchemeHostPort(), opaque_b.GetTupleOrPrecursorTupleIfOpaque());
- EXPECT_TRUE(opaque_b.GetTupleOrPrecursorTupleIfOpaque().IsInvalid());
+ EXPECT_FALSE(opaque_b.GetTupleOrPrecursorTupleIfOpaque().IsValid());
// Two default-constructed Origins should always be cross origin to each
// other.
@@ -304,7 +315,6 @@
// Registered URLs
{"ftp://example.com/", "ftp", "example.com", 21},
- {"gopher://example.com/", "gopher", "example.com", 70},
{"ws://example.com/", "ws", "example.com", 80},
{"wss://example.com/", "wss", "example.com", 443},
{"wss://user:pass@example.com/", "wss", "example.com", 443},
@@ -354,9 +364,6 @@
123},
{"blob:https://example.com/guid-goes-here", "https", "example.com", 443},
{"blob:http://u:p@example.com/guid-goes-here", "http", "example.com", 80},
-
- // Gopher:
- {"gopher://8u.9.Vx6", "gopher", "8u.9.vx6", 70},
};
for (const auto& test_case : cases) {
@@ -381,7 +388,7 @@
.DeriveNewOpaqueOrigin();
EXPECT_TRUE(derived_opaque.opaque());
EXPECT_NE(origin, derived_opaque);
- EXPECT_FALSE(derived_opaque.GetTupleOrPrecursorTupleIfOpaque().IsInvalid());
+ EXPECT_TRUE(derived_opaque.GetTupleOrPrecursorTupleIfOpaque().IsValid());
EXPECT_EQ(origin.GetTupleOrPrecursorTupleIfOpaque(),
derived_opaque.GetTupleOrPrecursorTupleIfOpaque());
EXPECT_EQ(derived_opaque, derived_opaque);
@@ -390,8 +397,8 @@
Origin::Resolve(GURL("data:text/html,baz"), origin);
EXPECT_TRUE(derived_opaque_via_data_url.opaque());
EXPECT_NE(origin, derived_opaque_via_data_url);
- EXPECT_FALSE(derived_opaque_via_data_url.GetTupleOrPrecursorTupleIfOpaque()
- .IsInvalid());
+ EXPECT_TRUE(derived_opaque_via_data_url.GetTupleOrPrecursorTupleIfOpaque()
+ .IsValid());
EXPECT_EQ(origin.GetTupleOrPrecursorTupleIfOpaque(),
derived_opaque_via_data_url.GetTupleOrPrecursorTupleIfOpaque());
EXPECT_NE(derived_opaque, derived_opaque_via_data_url);
@@ -627,9 +634,9 @@
};
for (const auto& test_case : kTestCases) {
- SCOPED_TRACE(testing::Message() << "(url, domain): (" << test_case.url
- << ", " << test_case.lower_ascii_domain
- << ")");
+ SCOPED_TRACE(testing::Message()
+ << "(url, domain): (" << test_case.url << ", "
+ << test_case.lower_ascii_domain << ")");
GURL url(test_case.url);
ASSERT_TRUE(url.is_valid());
Origin origin = Origin::Create(url);
@@ -660,6 +667,7 @@
Origin origin = Origin::Create(GURL("cow://"));
EXPECT_TRUE(origin.opaque());
}
+
TEST_F(OriginTest, NonStandardSchemeWithAndroidWebViewHack) {
EnableNonStandardSchemesForAndroidWebView();
Origin origin = Origin::Create(GURL("cow://"));
@@ -667,10 +675,10 @@
EXPECT_EQ("cow", origin.scheme());
EXPECT_EQ("", origin.host());
EXPECT_EQ(0, origin.port());
- ResetForTests();
}
TEST_F(OriginTest, CanBeDerivedFrom) {
+ AddStandardScheme("new-standard", SchemeType::SCHEME_WITH_HOST);
Origin opaque_unique_origin = Origin();
Origin regular_origin = Origin::Create(GURL("https://a.com/"));
@@ -688,7 +696,6 @@
non_standard_scheme_origin.DeriveNewOpaqueOrigin();
// Also, add new standard scheme that is local to the test.
- AddStandardScheme("new-standard", SchemeType::SCHEME_WITH_HOST);
Origin new_standard_origin = Origin::Create(GURL("new-standard://host/"));
Origin new_standard_opaque_precursor_origin =
new_standard_origin.DeriveNewOpaqueOrigin();
@@ -863,4 +870,78 @@
"file:// [internally: file://example.com]");
}
+TEST_F(OriginTest, Deserialize) {
+ std::vector<GURL> valid_urls = {
+ GURL("https://a.com"), GURL("http://a"),
+ GURL("http://a:80"), GURL("file://a.com/etc/passwd"),
+ GURL("file:///etc/passwd"), GURL("http://192.168.1.1"),
+ GURL("http://[2001:db8::1]/"),
+ };
+ for (const GURL& url : valid_urls) {
+ SCOPED_TRACE(url.spec());
+ Origin origin = Origin::Create(url);
+ gurl_base::Optional<std::string> serialized = SerializeWithNonce(origin);
+ ASSERT_TRUE(serialized);
+
+ gurl_base::Optional<Origin> deserialized = Deserialize(std::move(*serialized));
+ ASSERT_TRUE(deserialized.has_value());
+
+ EXPECT_TRUE(DoEqualityComparisons(origin, deserialized.value(), true));
+ EXPECT_EQ(origin.GetDebugString(), deserialized.value().GetDebugString());
+ }
+}
+
+TEST_F(OriginTest, DeserializeInvalid) {
+ EXPECT_EQ(gurl_base::nullopt, Deserialize(std::string()));
+ EXPECT_EQ(gurl_base::nullopt, Deserialize("deadbeef"));
+ EXPECT_EQ(gurl_base::nullopt, Deserialize("0123456789"));
+ EXPECT_EQ(gurl_base::nullopt, Deserialize("https://a.com"));
+ EXPECT_EQ(gurl_base::nullopt, Deserialize("https://192.168.1.1"));
+}
+
+TEST_F(OriginTest, SerializeTBDNonce) {
+ std::vector<GURL> invalid_urls = {
+ GURL("data:uniqueness"), GURL("data:,"),
+ GURL("data:text/html,Hello!"), GURL("javascript:alert(1)"),
+ GURL("about:blank"), GURL("google.com"),
+ };
+ for (const GURL& url : invalid_urls) {
+ SCOPED_TRACE(url.spec());
+ Origin origin = Origin::Create(url);
+ gurl_base::Optional<std::string> serialized = SerializeWithNonce(origin);
+ gurl_base::Optional<Origin> deserialized = Deserialize(std::move(*serialized));
+ ASSERT_TRUE(deserialized.has_value());
+
+ // Can't use DoEqualityComparisons here since empty nonces are never ==
+ // unless they are the same object.
+ EXPECT_EQ(origin.GetDebugString(), deserialized.value().GetDebugString());
+ }
+
+ // Same basic test as above, but without a GURL to create tuple_.
+ Origin opaque;
+ gurl_base::Optional<std::string> serialized = SerializeWithNonce(opaque);
+ ASSERT_TRUE(serialized);
+
+ gurl_base::Optional<Origin> deserialized = Deserialize(std::move(*serialized));
+ ASSERT_TRUE(deserialized.has_value());
+
+ // Can't use DoEqualityComparisons here since empty nonces are never == unless
+ // they are the same object.
+ EXPECT_EQ(opaque.GetDebugString(), deserialized.value().GetDebugString());
+}
+
+TEST_F(OriginTest, DeserializeValidNonce) {
+ Origin opaque;
+ GetNonce(opaque);
+
+ gurl_base::Optional<std::string> serialized = SerializeWithNonce(opaque);
+ ASSERT_TRUE(serialized);
+
+ gurl_base::Optional<Origin> deserialized = Deserialize(std::move(*serialized));
+ ASSERT_TRUE(deserialized.has_value());
+
+ EXPECT_TRUE(DoEqualityComparisons(opaque, deserialized.value(), true));
+ EXPECT_EQ(opaque.GetDebugString(), deserialized.value().GetDebugString());
+}
+
} // namespace url
diff --git a/url/scheme_host_port.cc b/url/scheme_host_port.cc
index 290e8a6..c90e0a7 100644
--- a/url/scheme_host_port.cc
+++ b/url/scheme_host_port.cc
@@ -134,15 +134,15 @@
ConstructPolicy policy)
: port_(0) {
if (!IsValidInput(scheme, host, port, policy)) {
- GURL_DCHECK(IsInvalid());
+ GURL_DCHECK(!IsValid());
return;
}
scheme_ = std::move(scheme);
host_ = std::move(host);
port_ = port;
- GURL_DCHECK(!IsInvalid()) << "Scheme: " << scheme_ << " Host: " << host_
- << " Port: " << port;
+ GURL_DCHECK(IsValid()) << "Scheme: " << scheme_ << " Host: " << host_
+ << " Port: " << port;
}
SchemeHostPort::SchemeHostPort(gurl_base::StringPiece scheme,
@@ -172,19 +172,19 @@
if (!IsValidInput(scheme, host, port, ALREADY_CANONICALIZED))
return;
- scheme.CopyToString(&scheme_);
- host.CopyToString(&host_);
+ scheme_ = std::string(scheme);
+ host_ = std::string(host);
port_ = port;
}
SchemeHostPort::~SchemeHostPort() = default;
-bool SchemeHostPort::IsInvalid() const {
+bool SchemeHostPort::IsValid() const {
// It suffices to just check |scheme_| for emptiness; the other fields are
// never present without it.
GURL_DCHECK(!scheme_.empty() || host_.empty());
GURL_DCHECK(!scheme_.empty() || port_ == 0);
- return scheme_.empty();
+ return !scheme_.empty();
}
std::string SchemeHostPort::Serialize() const {
@@ -198,7 +198,7 @@
url::Parsed parsed;
std::string serialized = SerializeInternal(&parsed);
- if (IsInvalid())
+ if (!IsValid())
return GURL(std::move(serialized), parsed, false);
// SchemeHostPort does not have enough information to determine if an empty
@@ -223,7 +223,7 @@
std::string SchemeHostPort::SerializeInternal(url::Parsed* parsed) const {
std::string result;
- if (IsInvalid())
+ if (!IsValid())
return result;
// Reserve enough space for the "normal" case of scheme://host/.
diff --git a/url/scheme_host_port.h b/url/scheme_host_port.h
index a2dded1..903a398 100644
--- a/url/scheme_host_port.h
+++ b/url/scheme_host_port.h
@@ -122,7 +122,7 @@
const std::string& host() const { return host_; }
const std::string& scheme() const { return scheme_; }
uint16_t port() const { return port_; }
- bool IsInvalid() const;
+ bool IsValid() const;
// Serializes the SchemeHostPort tuple to a canonical form.
//
diff --git a/url/scheme_host_port_unittest.cc b/url/scheme_host_port_unittest.cc
index 5270c70..e3bcade 100644
--- a/url/scheme_host_port_unittest.cc
+++ b/url/scheme_host_port_unittest.cc
@@ -16,12 +16,11 @@
class SchemeHostPortTest : public testing::Test {
public:
SchemeHostPortTest() = default;
- ~SchemeHostPortTest() override {
- // Reset any added schemes.
- url::ResetForTests();
- }
+ ~SchemeHostPortTest() override = default;
private:
+ url::ScopedSchemeRegistryForTests scoped_registry_;
+
DISALLOW_COPY_AND_ASSIGN(SchemeHostPortTest);
};
@@ -52,7 +51,7 @@
EXPECT_EQ("", invalid.scheme());
EXPECT_EQ("", invalid.host());
EXPECT_EQ(0, invalid.port());
- EXPECT_TRUE(invalid.IsInvalid());
+ EXPECT_FALSE(invalid.IsValid());
EXPECT_EQ(invalid, invalid);
const char* urls[] = {
@@ -76,7 +75,7 @@
EXPECT_EQ("", tuple.scheme());
EXPECT_EQ("", tuple.host());
EXPECT_EQ(0, tuple.port());
- EXPECT_TRUE(tuple.IsInvalid());
+ EXPECT_FALSE(tuple.IsValid());
EXPECT_EQ(tuple, tuple);
EXPECT_EQ(tuple, invalid);
EXPECT_EQ(invalid, tuple);
@@ -105,7 +104,7 @@
EXPECT_EQ(test.scheme, tuple.scheme());
EXPECT_EQ(test.host, tuple.host());
EXPECT_EQ(test.port, tuple.port());
- EXPECT_FALSE(tuple.IsInvalid());
+ EXPECT_TRUE(tuple.IsValid());
EXPECT_EQ(tuple, tuple);
ExpectParsedUrlsEqual(GURL(tuple.Serialize()), tuple.GetURL());
}
@@ -141,7 +140,7 @@
EXPECT_EQ("", tuple.scheme());
EXPECT_EQ("", tuple.host());
EXPECT_EQ(0, tuple.port());
- EXPECT_TRUE(tuple.IsInvalid());
+ EXPECT_FALSE(tuple.IsValid());
EXPECT_EQ(tuple, tuple);
ExpectParsedUrlsEqual(GURL(tuple.Serialize()), tuple.GetURL());
}
@@ -170,7 +169,7 @@
EXPECT_EQ("", tuple.scheme());
EXPECT_EQ("", tuple.host());
EXPECT_EQ(0, tuple.port());
- EXPECT_TRUE(tuple.IsInvalid());
+ EXPECT_FALSE(tuple.IsValid());
ExpectParsedUrlsEqual(GURL(tuple.Serialize()), tuple.GetURL());
}
}
@@ -205,7 +204,7 @@
EXPECT_EQ(test.scheme, tuple.scheme());
EXPECT_EQ(test.host, tuple.host());
EXPECT_EQ(test.port, tuple.port());
- EXPECT_FALSE(tuple.IsInvalid());
+ EXPECT_TRUE(tuple.IsValid());
EXPECT_EQ(tuple, tuple);
ExpectParsedUrlsEqual(GURL(tuple.Serialize()), tuple.GetURL());
}
diff --git a/url/url_canon_relative.cc b/url/url_canon_relative.cc
index 47668f6..a5ec808 100644
--- a/url/url_canon_relative.cc
+++ b/url/url_canon_relative.cc
@@ -7,6 +7,7 @@
#include <algorithm>
#include "polyfills/base/logging.h"
+#include "base/strings/string_util.h"
#include "url/url_canon.h"
#include "url/url_canon_internal.h"
#include "url/url_constants.h"
@@ -62,6 +63,39 @@
#endif // WIN32
+template <typename CHAR>
+bool IsValidScheme(const CHAR* url, const Component& scheme) {
+ // Caller should ensure that the |scheme| is not empty.
+ GURL_DCHECK_NE(0, scheme.len);
+
+ // From https://url.spec.whatwg.org/#scheme-start-state:
+ // scheme start state:
+ // 1. If c is an ASCII alpha, append c, lowercased, to buffer, and set
+ // state to scheme state.
+ // 2. Otherwise, if state override is not given, set state to no scheme
+ // state, and decrease pointer by one.
+ // 3. Otherwise, validation error, return failure.
+ // Note that both step 2 and step 3 mean that the scheme was not valid.
+ if (!gurl_base::IsAsciiAlpha(url[scheme.begin]))
+ return false;
+
+ // From https://url.spec.whatwg.org/#scheme-state:
+ // scheme state:
+ // 1. If c is an ASCII alphanumeric, U+002B (+), U+002D (-), or U+002E
+ // (.), append c, lowercased, to buffer.
+ // 2. Otherwise, if c is U+003A (:), then [...]
+ //
+ // We begin at |scheme.begin + 1|, because the character at |scheme.begin| has
+ // already been checked by gurl_base::IsAsciiAlpha above.
+ int scheme_end = scheme.end();
+ for (int i = scheme.begin + 1; i < scheme_end; i++) {
+ if (!CanonicalSchemeChar(url[i]))
+ return false;
+ }
+
+ return true;
+}
+
// See IsRelativeURL in the header file for usage.
template<typename CHAR>
bool DoIsRelativeURL(const char* base,
@@ -126,17 +160,14 @@
}
// If the scheme isn't valid, then it's relative.
- int scheme_end = scheme.end();
- for (int i = scheme.begin; i < scheme_end; i++) {
- if (!CanonicalSchemeChar(url[i])) {
- if (!is_base_hierarchical) {
- // Don't allow relative URLs if the base scheme doesn't support it.
- return false;
- }
- *relative_component = MakeRange(begin, url_len);
- *is_relative = true;
- return true;
+ if (!IsValidScheme(url, scheme)) {
+ if (!is_base_hierarchical) {
+ // Don't allow relative URLs if the base scheme doesn't support it.
+ return false;
}
+ *relative_component = MakeRange(begin, url_len);
+ *is_relative = true;
+ return true;
}
// If the scheme is not the same, then we can't count it as relative.
@@ -287,9 +318,8 @@
// Canonical URLs always have a path, so we can use that offset. Reserve
// enough room for the base URL, the new path, and some extra bytes for
// possible escaped characters.
- output->ReserveSizeIfNeeded(
- base_parsed.path.begin +
- std::max(path.end(), std::max(query.end(), ref.end())));
+ output->ReserveSizeIfNeeded(base_parsed.path.begin +
+ std::max({path.end(), query.end(), ref.end()}));
output->Append(base_url, base_parsed.path.begin);
if (path.len > 0) {
diff --git a/url/url_canon_stdurl.cc b/url/url_canon_stdurl.cc
index 78f7773..6a94f50 100644
--- a/url/url_canon_stdurl.cc
+++ b/url/url_canon_stdurl.cc
@@ -128,10 +128,6 @@
else if (!strncmp(scheme, kWssScheme, scheme_len))
default_port = 443;
break;
- case 6:
- if (!strncmp(scheme, kGopherScheme, scheme_len))
- default_port = 70;
- break;
case 2:
if (!strncmp(scheme, kWsScheme, scheme_len))
default_port = 80;
diff --git a/url/url_canon_unittest.cc b/url/url_canon_unittest.cc
index 9d1a458..c3f02fb 100644
--- a/url/url_canon_unittest.cc
+++ b/url/url_canon_unittest.cc
@@ -1393,7 +1393,7 @@
{"https://foo:80/", "https://foo:80/", true},
{"ftp://foo:21/", "ftp://foo/", true},
{"ftp://foo:80/", "ftp://foo:80/", true},
- {"gopher://foo:70/", "gopher://foo/", true},
+ {"gopher://foo:70/", "gopher://foo:70/", true},
{"gopher://foo:443/", "gopher://foo:443/", true},
{"ws://foo:80/", "ws://foo/", true},
{"ws://foo:81/", "ws://foo:81/", true},
@@ -2325,14 +2325,12 @@
{"ftp", 21},
{"ws", 80},
{"wss", 443},
- {"gopher", 70},
{"fake-scheme", PORT_UNSPECIFIED},
{"HTTP", PORT_UNSPECIFIED},
{"HTTPS", PORT_UNSPECIFIED},
{"FTP", PORT_UNSPECIFIED},
{"WS", PORT_UNSPECIFIED},
{"WSS", PORT_UNSPECIFIED},
- {"GOPHER", PORT_UNSPECIFIED},
};
for (auto& test_case : cases) {
diff --git a/url/url_constants.cc b/url/url_constants.cc
index 3540240..69399e4 100644
--- a/url/url_constants.cc
+++ b/url/url_constants.cc
@@ -20,11 +20,13 @@
const char kFileScheme[] = "file";
const char kFileSystemScheme[] = "filesystem";
const char kFtpScheme[] = "ftp";
-const char kGopherScheme[] = "gopher";
const char kHttpScheme[] = "http";
const char kHttpsScheme[] = "https";
const char kJavaScriptScheme[] = "javascript";
const char kMailToScheme[] = "mailto";
+// This is for QuicTransport (https://wicg.github.io/web-transport/).
+// See also: https://www.iana.org/assignments/uri-schemes/prov/quic-transport
+const char kQuicTransportScheme[] = "quic-transport";
const char kTelScheme[] = "tel";
const char kWsScheme[] = "ws";
const char kWssScheme[] = "wss";
diff --git a/url/url_constants.h b/url/url_constants.h
index c077b8d..3c04d68 100644
--- a/url/url_constants.h
+++ b/url/url_constants.h
@@ -26,11 +26,11 @@
COMPONENT_EXPORT(URL) extern const char kFileScheme[];
COMPONENT_EXPORT(URL) extern const char kFileSystemScheme[];
COMPONENT_EXPORT(URL) extern const char kFtpScheme[];
-COMPONENT_EXPORT(URL) extern const char kGopherScheme[];
COMPONENT_EXPORT(URL) extern const char kHttpScheme[];
COMPONENT_EXPORT(URL) extern const char kHttpsScheme[];
COMPONENT_EXPORT(URL) extern const char kJavaScriptScheme[];
COMPONENT_EXPORT(URL) extern const char kMailToScheme[];
+COMPONENT_EXPORT(URL) extern const char kQuicTransportScheme[];
COMPONENT_EXPORT(URL) extern const char kTelScheme[];
COMPONENT_EXPORT(URL) extern const char kWsScheme[];
COMPONENT_EXPORT(URL) extern const char kWssScheme[];
diff --git a/url/url_util.cc b/url/url_util.cc
index 47fc499..7c72bfc 100644
--- a/url/url_util.cc
+++ b/url/url_util.cc
@@ -6,8 +6,9 @@
#include <stddef.h>
#include <string.h>
+#include <atomic>
-#include "base/debug/leak_annotations.h"
+#include "base/compiler_specific.h"
#include "polyfills/base/logging.h"
#include "base/no_destructor.h"
#include "base/stl_util.h"
@@ -21,6 +22,12 @@
namespace {
+// A pair for representing a standard scheme name and the SchemeType for it.
+struct SchemeWithType {
+ std::string scheme;
+ SchemeType type;
+};
+
// List of currently registered schemes and associated properties.
struct SchemeRegistry {
// Standard format schemes (see header for details).
@@ -34,11 +41,11 @@
// canonicalization.
{kFileScheme, SCHEME_WITH_HOST},
{kFtpScheme, SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION},
- {kGopherScheme, SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION},
{kWssScheme,
SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION}, // WebSocket secure.
{kWsScheme, SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION}, // WebSocket.
{kFileSystemScheme, SCHEME_WITHOUT_AUTHORITY},
+ {kQuicTransportScheme, SCHEME_WITH_HOST_AND_PORT},
};
// Schemes that are allowed for referrers.
@@ -49,10 +56,7 @@
// Schemes that do not trigger mixed content warning.
std::vector<std::string> secure_schemes = {
- kHttpsScheme,
- kAboutScheme,
- kDataScheme,
- kWssScheme,
+ kHttpsScheme, kAboutScheme, kDataScheme, kQuicTransportScheme, kWssScheme,
};
// Schemes that normal pages cannot link to or access (i.e., with the same
@@ -93,11 +97,26 @@
bool allow_non_standard_schemes = false;
};
-SchemeRegistry* GetSchemeRegistry() {
+// See the LockSchemeRegistries declaration in the header.
+bool scheme_registries_locked = false;
+
+// Ensure that the schemes aren't modified after first use.
+static std::atomic<bool> g_scheme_registries_used{false};
+
+// Gets the scheme registry without locking the schemes. This should *only* be
+// used for adding schemes to the registry.
+SchemeRegistry* GetSchemeRegistryWithoutLocking() {
static gurl_base::NoDestructor<SchemeRegistry> registry;
return registry.get();
}
+const SchemeRegistry& GetSchemeRegistry() {
+#if GURL_DCHECK_IS_ON()
+ g_scheme_registries_used.store(true);
+#endif
+ return *GetSchemeRegistryWithoutLocking();
+}
+
// Pass this enum through for methods which would like to know if whitespace
// removal is necessary.
enum WhitespaceRemovalPolicy {
@@ -105,9 +124,6 @@
DO_NOT_REMOVE_WHITESPACE,
};
-// See the LockSchemeRegistries declaration in the header.
-bool scheme_registries_locked = false;
-
// This template converts a given character type to the corresponding
// StringPiece type.
template<typename CHAR> struct CharToStringPiece {
@@ -157,7 +173,7 @@
template<typename CHAR>
bool DoIsStandard(const CHAR* spec, const Component& scheme, SchemeType* type) {
return DoIsInSchemes(spec, scheme, type,
- GetSchemeRegistry()->standard_schemes);
+ GetSchemeRegistry().standard_schemes);
}
@@ -168,7 +184,7 @@
Component* found_scheme) {
// Before extracting scheme, canonicalize the URL to remove any whitespace.
// This matches the canonicalization done in DoCanonicalize function.
- RawCanonOutputT<CHAR> whitespace_buffer;
+ STACK_UNINITIALIZED RawCanonOutputT<CHAR> whitespace_buffer;
int spec_len;
const CHAR* spec =
RemoveURLWhitespace(str, str_len, &whitespace_buffer, &spec_len, nullptr);
@@ -197,7 +213,7 @@
// Remove any whitespace from the middle of the relative URL if necessary.
// Possibly this will result in copying to the new buffer.
- RawCanonOutputT<CHAR> whitespace_buffer;
+ STACK_UNINITIALIZED RawCanonOutputT<CHAR> whitespace_buffer;
if (whitespace_policy == REMOVE_WHITESPACE) {
spec = RemoveURLWhitespace(spec, spec_len, &whitespace_buffer, &spec_len,
&output_parsed->potentially_dangling_markup);
@@ -276,7 +292,7 @@
Parsed* output_parsed) {
// Remove any whitespace from the middle of the relative URL, possibly
// copying to the new buffer.
- RawCanonOutputT<CHAR> whitespace_buffer;
+ STACK_UNINITIALIZED RawCanonOutputT<CHAR> whitespace_buffer;
int relative_length;
const CHAR* relative = RemoveURLWhitespace(
in_relative, in_relative_length, &whitespace_buffer, &relative_length,
@@ -317,7 +333,7 @@
Parsed base_parsed_authority;
ParseStandardURL(base_spec, base_spec_len, &base_parsed_authority);
if (base_parsed_authority.host.is_nonempty()) {
- RawCanonOutputT<char> temporary_output;
+ STACK_UNINITIALIZED RawCanonOutputT<char> temporary_output;
bool did_resolve_succeed =
ResolveRelativeURL(base_spec, base_parsed_authority, false, relative,
relative_component, charset_converter,
@@ -369,7 +385,7 @@
if (replacements.IsSchemeOverridden()) {
// Canonicalize the new scheme so it is 8-bit and can be concatenated with
// the existing spec.
- RawCanonOutput<128> scheme_replaced;
+ STACK_UNINITIALIZED RawCanonOutput<128> scheme_replaced;
Component scheme_replaced_parsed;
CanonicalizeScheme(replacements.sources().scheme,
replacements.components().scheme,
@@ -386,7 +402,7 @@
// We now need to completely re-parse the resulting string since its meaning
// may have changed with the different scheme.
- RawCanonOutput<128> recanonicalized;
+ STACK_UNINITIALIZED RawCanonOutput<128> recanonicalized;
Parsed recanonicalized_parsed;
DoCanonicalize(scheme_replaced.data(), scheme_replaced.length(), true,
REMOVE_WHITESPACE, charset_converter, &recanonicalized,
@@ -441,8 +457,16 @@
return ReplacePathURL(spec, parsed, replacements, output, out_parsed);
}
-void DoAddScheme(const char* new_scheme, std::vector<std::string>* schemes) {
- GURL_DCHECK(schemes);
+void DoSchemeModificationPreamble() {
+ // If this assert triggers, it means you've called Add*Scheme after
+ // the SchemeRegistry has been used.
+ //
+ // This normally means you're trying to set up a new scheme too late or using
+ // the SchemeRegistry too early in your application's init process. Make sure
+ // that you haven't added any static GURL initializers in tests.
+ GURL_DCHECK(!g_scheme_registries_used.load())
+ << "Trying to add a scheme after the lists have been used.";
+
// If this assert triggers, it means you've called Add*Scheme after
// LockSchemeRegistries has been called (see the header file for
// LockSchemeRegistries for more).
@@ -452,122 +476,145 @@
// and calls LockSchemeRegistries, and add your new scheme there.
GURL_DCHECK(!scheme_registries_locked)
<< "Trying to add a scheme after the lists have been locked.";
+}
- size_t scheme_len = strlen(new_scheme);
- if (scheme_len == 0)
- return;
-
+void DoAddScheme(const char* new_scheme, std::vector<std::string>* schemes) {
+ DoSchemeModificationPreamble();
+ GURL_DCHECK(schemes);
+ GURL_DCHECK(strlen(new_scheme) > 0);
GURL_DCHECK_EQ(gurl_base::ToLowerASCII(new_scheme), new_scheme);
- schemes->push_back(std::string(new_scheme));
+ GURL_DCHECK(std::find(schemes->begin(), schemes->end(), new_scheme) ==
+ schemes->end());
+ schemes->push_back(new_scheme);
}
void DoAddSchemeWithType(const char* new_scheme,
SchemeType type,
std::vector<SchemeWithType>* schemes) {
+ DoSchemeModificationPreamble();
GURL_DCHECK(schemes);
- // If this assert triggers, it means you've called Add*Scheme after
- // LockSchemeRegistries has been called (see the header file for
- // LockSchemeRegistries for more).
- //
- // This normally means you're trying to set up a new scheme too late in your
- // application's init process. Locate where your app does this initialization
- // and calls LockSchemeRegistries, and add your new scheme there.
- GURL_DCHECK(!scheme_registries_locked)
- << "Trying to add a scheme after the lists have been locked.";
-
- size_t scheme_len = strlen(new_scheme);
- if (scheme_len == 0)
- return;
-
+ GURL_DCHECK(strlen(new_scheme) > 0);
GURL_DCHECK_EQ(gurl_base::ToLowerASCII(new_scheme), new_scheme);
- // Duplicate the scheme into a new buffer and add it to the list of standard
- // schemes. This pointer will be leaked on shutdown.
- char* dup_scheme = new char[scheme_len + 1];
- ANNOTATE_LEAKING_OBJECT_PTR(dup_scheme);
- memcpy(dup_scheme, new_scheme, scheme_len + 1);
-
- SchemeWithType scheme_with_type;
- scheme_with_type.scheme = dup_scheme;
- scheme_with_type.type = type;
- schemes->push_back(scheme_with_type);
+ GURL_DCHECK(std::find_if(schemes->begin(), schemes->end(),
+ [&new_scheme](const SchemeWithType& scheme) {
+ return scheme.scheme == new_scheme;
+ }) == schemes->end());
+ schemes->push_back({new_scheme, type});
}
} // namespace
-void ResetForTests() {
- *GetSchemeRegistry() = SchemeRegistry();
+void ClearSchemesForTests() {
+ GURL_DCHECK(!g_scheme_registries_used.load())
+ << "Schemes already used "
+ << "(use ScopedSchemeRegistryForTests to relax for tests).";
+ GURL_DCHECK(!scheme_registries_locked)
+ << "Schemes already locked "
+ << "(use ScopedSchemeRegistryForTests to relax for tests).";
+ *GetSchemeRegistryWithoutLocking() = SchemeRegistry();
}
+class ScopedSchemeRegistryInternal {
+ public:
+ ScopedSchemeRegistryInternal()
+ : registry_(std::make_unique<SchemeRegistry>(
+ *GetSchemeRegistryWithoutLocking())) {
+ g_scheme_registries_used.store(false);
+ scheme_registries_locked = false;
+ }
+ ~ScopedSchemeRegistryInternal() {
+ *GetSchemeRegistryWithoutLocking() = *registry_;
+ g_scheme_registries_used.store(true);
+ scheme_registries_locked = true;
+ }
+
+ private:
+ std::unique_ptr<SchemeRegistry> registry_;
+};
+
+ScopedSchemeRegistryForTests::ScopedSchemeRegistryForTests()
+ : internal_(std::make_unique<ScopedSchemeRegistryInternal>()) {}
+
+ScopedSchemeRegistryForTests::~ScopedSchemeRegistryForTests() = default;
+
void EnableNonStandardSchemesForAndroidWebView() {
- GetSchemeRegistry()->allow_non_standard_schemes = true;
+ DoSchemeModificationPreamble();
+ GetSchemeRegistryWithoutLocking()->allow_non_standard_schemes = true;
}
bool AllowNonStandardSchemesForAndroidWebView() {
- return GetSchemeRegistry()->allow_non_standard_schemes;
+ return GetSchemeRegistry().allow_non_standard_schemes;
}
void AddStandardScheme(const char* new_scheme, SchemeType type) {
- DoAddSchemeWithType(new_scheme, type, &GetSchemeRegistry()->standard_schemes);
+ DoAddSchemeWithType(new_scheme, type,
+ &GetSchemeRegistryWithoutLocking()->standard_schemes);
}
void AddReferrerScheme(const char* new_scheme, SchemeType type) {
- DoAddSchemeWithType(new_scheme, type, &GetSchemeRegistry()->referrer_schemes);
+ DoAddSchemeWithType(new_scheme, type,
+ &GetSchemeRegistryWithoutLocking()->referrer_schemes);
}
void AddSecureScheme(const char* new_scheme) {
- DoAddScheme(new_scheme, &GetSchemeRegistry()->secure_schemes);
+ DoAddScheme(new_scheme, &GetSchemeRegistryWithoutLocking()->secure_schemes);
}
const std::vector<std::string>& GetSecureSchemes() {
- return GetSchemeRegistry()->secure_schemes;
+ return GetSchemeRegistry().secure_schemes;
}
void AddLocalScheme(const char* new_scheme) {
- DoAddScheme(new_scheme, &GetSchemeRegistry()->local_schemes);
+ DoAddScheme(new_scheme, &GetSchemeRegistryWithoutLocking()->local_schemes);
}
const std::vector<std::string>& GetLocalSchemes() {
- return GetSchemeRegistry()->local_schemes;
+ return GetSchemeRegistry().local_schemes;
}
void AddNoAccessScheme(const char* new_scheme) {
- DoAddScheme(new_scheme, &GetSchemeRegistry()->no_access_schemes);
+ DoAddScheme(new_scheme,
+ &GetSchemeRegistryWithoutLocking()->no_access_schemes);
}
const std::vector<std::string>& GetNoAccessSchemes() {
- return GetSchemeRegistry()->no_access_schemes;
+ return GetSchemeRegistry().no_access_schemes;
}
void AddCorsEnabledScheme(const char* new_scheme) {
- DoAddScheme(new_scheme, &GetSchemeRegistry()->cors_enabled_schemes);
+ DoAddScheme(new_scheme,
+ &GetSchemeRegistryWithoutLocking()->cors_enabled_schemes);
}
const std::vector<std::string>& GetCorsEnabledSchemes() {
- return GetSchemeRegistry()->cors_enabled_schemes;
+ return GetSchemeRegistry().cors_enabled_schemes;
}
void AddWebStorageScheme(const char* new_scheme) {
- DoAddScheme(new_scheme, &GetSchemeRegistry()->web_storage_schemes);
+ DoAddScheme(new_scheme,
+ &GetSchemeRegistryWithoutLocking()->web_storage_schemes);
}
const std::vector<std::string>& GetWebStorageSchemes() {
- return GetSchemeRegistry()->web_storage_schemes;
+ return GetSchemeRegistry().web_storage_schemes;
}
void AddCSPBypassingScheme(const char* new_scheme) {
- DoAddScheme(new_scheme, &GetSchemeRegistry()->csp_bypassing_schemes);
+ DoAddScheme(new_scheme,
+ &GetSchemeRegistryWithoutLocking()->csp_bypassing_schemes);
}
const std::vector<std::string>& GetCSPBypassingSchemes() {
- return GetSchemeRegistry()->csp_bypassing_schemes;
+ return GetSchemeRegistry().csp_bypassing_schemes;
}
void AddEmptyDocumentScheme(const char* new_scheme) {
- DoAddScheme(new_scheme, &GetSchemeRegistry()->empty_document_schemes);
+ DoAddScheme(new_scheme,
+ &GetSchemeRegistryWithoutLocking()->empty_document_schemes);
}
const std::vector<std::string>& GetEmptyDocumentSchemes() {
- return GetSchemeRegistry()->empty_document_schemes;
+ return GetSchemeRegistry().empty_document_schemes;
}
void LockSchemeRegistries() {
@@ -599,7 +646,7 @@
bool IsReferrerScheme(const char* spec, const Component& scheme) {
SchemeType unused_scheme_type;
return DoIsInSchemes(spec, scheme, &unused_scheme_type,
- GetSchemeRegistry()->referrer_schemes);
+ GetSchemeRegistry().referrer_schemes);
}
bool FindAndCompareScheme(const char* str,
@@ -653,7 +700,7 @@
}
bool HostIsIPAddress(gurl_base::StringPiece host) {
- url::RawCanonOutputT<char, 128> ignored_output;
+ STACK_UNINITIALIZED url::RawCanonOutputT<char, 128> ignored_output;
url::CanonHostInfo host_info;
url::CanonicalizeIPAddress(host.data(), Component(0, host.length()),
&ignored_output, &host_info);
@@ -732,7 +779,7 @@
int length,
DecodeURLMode mode,
CanonOutputW* output) {
- RawCanonOutputT<char> unescaped_chars;
+ STACK_UNINITIALIZED RawCanonOutputT<char> unescaped_chars;
for (int i = 0; i < length; i++) {
if (input[i] == '%') {
unsigned char ch;
diff --git a/url/url_util.h b/url/url_util.h
index 473ae5f..1816637 100644
--- a/url/url_util.h
+++ b/url/url_util.h
@@ -5,6 +5,7 @@
#ifndef URL_URL_UTIL_H_
#define URL_URL_UTIL_H_
+#include <memory>
#include <string>
#include <vector>
@@ -19,8 +20,22 @@
// Init ------------------------------------------------------------------------
-// Resets all custom schemes to the default values. Not thread-safe.
-COMPONENT_EXPORT(URL) void ResetForTests();
+// Used for tests that need to reset schemes. Note that this can only be used
+// in conjunction with ScopedSchemeRegistryForTests.
+COMPONENT_EXPORT(URL) void ClearSchemesForTests();
+
+class ScopedSchemeRegistryInternal;
+
+// Stores the SchemeRegistry upon creation, allowing tests to modify a copy of
+// it, and restores the original SchemeRegistry when deleted.
+class COMPONENT_EXPORT(URL) ScopedSchemeRegistryForTests {
+ public:
+ ScopedSchemeRegistryForTests();
+ ~ScopedSchemeRegistryForTests();
+
+ private:
+ std::unique_ptr<ScopedSchemeRegistryInternal> internal_;
+};
// Schemes ---------------------------------------------------------------------
@@ -37,15 +52,9 @@
// Whether or not SchemeHostPort and Origin allow non-standard schemes.
COMPONENT_EXPORT(URL) bool AllowNonStandardSchemesForAndroidWebView();
-// A pair for representing a standard scheme name and the SchemeType for it.
-struct COMPONENT_EXPORT(URL) SchemeWithType {
- const char* scheme;
- SchemeType type;
-};
-
// The following Add*Scheme method are not threadsafe and can not be called
// concurrently with any other url_util function. They will assert if the lists
-// of schemes have been locked (see LockSchemeRegistries).
+// of schemes have been locked (see LockSchemeRegistries), or used.
// Adds an application-defined scheme to the internal list of "standard-format"
// URL schemes. A standard-format scheme adheres to what RFC 3986 calls "generic
diff --git a/url/url_util_unittest.cc b/url/url_util_unittest.cc
index 741c1dc..a63294f 100644
--- a/url/url_util_unittest.cc
+++ b/url/url_util_unittest.cc
@@ -17,12 +17,11 @@
class URLUtilTest : public testing::Test {
public:
URLUtilTest() = default;
- ~URLUtilTest() override {
- // Reset any added schemes.
- ResetForTests();
- }
+ ~URLUtilTest() override = default;
private:
+ ScopedSchemeRegistryForTests scoped_registry_;
+
DISALLOW_COPY_AND_ASSIGN(URLUtilTest);
};
@@ -92,21 +91,24 @@
}
TEST_F(URLUtilTest, AddReferrerScheme) {
- const char kFooScheme[] = "foo";
+ static const char kFooScheme[] = "foo";
EXPECT_FALSE(IsReferrerScheme(kFooScheme, Component(0, strlen(kFooScheme))));
+ url::ScopedSchemeRegistryForTests scoped_registry;
AddReferrerScheme(kFooScheme, url::SCHEME_WITH_HOST);
EXPECT_TRUE(IsReferrerScheme(kFooScheme, Component(0, strlen(kFooScheme))));
}
TEST_F(URLUtilTest, ShutdownCleansUpSchemes) {
- const char kFooScheme[] = "foo";
+ static const char kFooScheme[] = "foo";
EXPECT_FALSE(IsReferrerScheme(kFooScheme, Component(0, strlen(kFooScheme))));
- AddReferrerScheme(kFooScheme, url::SCHEME_WITH_HOST);
- EXPECT_TRUE(IsReferrerScheme(kFooScheme, Component(0, strlen(kFooScheme))));
+ {
+ url::ScopedSchemeRegistryForTests scoped_registry;
+ AddReferrerScheme(kFooScheme, url::SCHEME_WITH_HOST);
+ EXPECT_TRUE(IsReferrerScheme(kFooScheme, Component(0, strlen(kFooScheme))));
+ }
- ResetForTests();
EXPECT_FALSE(IsReferrerScheme(kFooScheme, Component(0, strlen(kFooScheme))));
}
