Rename typefdefs for C++17
These typedefs are no longer necessary:
base::char16 -> char16_t
base::string16 -> std::u16string
base::StringPiece -> std::string_view
base::StringPiece16 -> std::u16string_view
There should be no behavior change since the objects are already the
C++17 types.
Change-Id: I482a9371bc668e72d12811c17b4f1128715ea62a
Reviewed-on: https://gn-review.googlesource.com/c/gn/+/6060
Reviewed-by: Scott Graham <scottmg@chromium.org>
Commit-Queue: Brett Wilson <brettw@chromium.org>
diff --git a/base/command_line.cc b/base/command_line.cc
index b2bf5a8..d6695a3 100644
--- a/base/command_line.cc
+++ b/base/command_line.cc
@@ -107,21 +107,21 @@
#if defined(OS_WIN)
// Quote a string as necessary for CommandLineToArgvW compatiblity *on Windows*.
-string16 QuoteForCommandLineToArgvW(const string16& arg,
- bool quote_placeholders) {
+std::u16string QuoteForCommandLineToArgvW(const std::u16string& arg,
+ bool quote_placeholders) {
// We follow the quoting rules of CommandLineToArgvW.
// http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
- string16 quotable_chars(u" \\\"");
+ std::u16string quotable_chars(u" \\\"");
// We may also be required to quote '%', which is commonly used in a command
// line as a placeholder. (It may be substituted for a string with spaces.)
if (quote_placeholders)
quotable_chars.push_back('%');
- if (arg.find_first_of(quotable_chars) == string16::npos) {
+ if (arg.find_first_of(quotable_chars) == std::u16string::npos) {
// No quoting necessary.
return arg;
}
- string16 out;
+ std::u16string out;
out.push_back('"');
for (size_t i = 0; i < arg.size(); ++i) {
if (arg[i] == '\\') {
@@ -195,7 +195,7 @@
void CommandLine::InitUsingArgvForTesting(int argc, const char* const* argv) {
DCHECK(!current_process_commandline_);
current_process_commandline_ = new CommandLine(NO_PROGRAM);
- // On Windows we need to convert the command line arguments to string16.
+ // On Windows we need to convert the command line arguments to std::u16string.
base::CommandLine::StringVector argv_vector;
for (int i = 0; i < argc; ++i)
argv_vector.push_back(UTF8ToUTF16(argv[i]));
@@ -245,7 +245,7 @@
#if defined(OS_WIN)
// static
-CommandLine CommandLine::FromString(const string16& command_line) {
+CommandLine CommandLine::FromString(const std::u16string& command_line) {
CommandLine cmd(NO_PROGRAM);
cmd.ParseFromString(command_line);
return cmd;
@@ -282,17 +282,17 @@
#endif
}
-bool CommandLine::HasSwitch(const base::StringPiece& switch_string) const {
+bool CommandLine::HasSwitch(const std::string_view& switch_string) const {
DCHECK_EQ(ToLowerASCII(switch_string), switch_string);
return ContainsKey(switches_, switch_string);
}
bool CommandLine::HasSwitch(const char switch_constant[]) const {
- return HasSwitch(base::StringPiece(switch_constant));
+ return HasSwitch(std::string_view(switch_constant));
}
std::string CommandLine::GetSwitchValueASCII(
- const base::StringPiece& switch_string) const {
+ const std::string_view& switch_string) const {
StringType value = GetSwitchValueNative(switch_string);
if (!IsStringASCII(value)) {
DLOG(WARNING) << "Value of switch (" << switch_string << ") must be ASCII.";
@@ -306,12 +306,12 @@
}
FilePath CommandLine::GetSwitchValuePath(
- const base::StringPiece& switch_string) const {
+ const std::string_view& switch_string) const {
return FilePath(GetSwitchValueNative(switch_string));
}
CommandLine::StringType CommandLine::GetSwitchValueNative(
- const base::StringPiece& switch_string) const {
+ const std::string_view& switch_string) const {
DCHECK_EQ(ToLowerASCII(switch_string), switch_string);
auto result = switches_.find(switch_string);
return result == switches_.end() ? StringType() : result->second;
@@ -424,8 +424,8 @@
}
#if defined(OS_WIN)
-void CommandLine::ParseFromString(const string16& command_line) {
- string16 command_line_string;
+void CommandLine::ParseFromString(const std::u16string& command_line) {
+ std::u16string command_line_string;
TrimWhitespace(command_line, TRIM_ALL, &command_line_string);
if (command_line_string.empty())
return;
diff --git a/base/command_line.h b/base/command_line.h
index 0161457..46c1fcc 100644
--- a/base/command_line.h
+++ b/base/command_line.h
@@ -18,10 +18,9 @@
#include <stddef.h>
#include <map>
#include <string>
+#include <string_view>
#include <vector>
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
#include "util/build_config.h"
namespace base {
@@ -32,7 +31,7 @@
public:
#if defined(OS_WIN)
// The native command line string type.
- using StringType = string16;
+ using StringType = std::u16string;
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
using StringType = std::string;
#endif
@@ -100,7 +99,7 @@
static bool InitializedForCurrentProcess();
#if defined(OS_WIN)
- static CommandLine FromString(const string16& command_line);
+ static CommandLine FromString(const std::u16string& command_line);
#endif
// Initialize from an argv vector.
@@ -164,16 +163,16 @@
// Switch names must be lowercase.
// The second override provides an optimized version to avoid inlining codegen
// at every callsite to find the length of the constant and construct a
- // StringPiece.
- bool HasSwitch(const StringPiece& switch_string) const;
+ // std::string_view.
+ bool HasSwitch(const std::string_view& switch_string) const;
bool HasSwitch(const char switch_constant[]) const;
// Returns the value associated with the given switch. If the switch has no
// value or isn't present, this method returns the empty string.
// Switch names must be lowercase.
- std::string GetSwitchValueASCII(const StringPiece& switch_string) const;
- FilePath GetSwitchValuePath(const StringPiece& switch_string) const;
- StringType GetSwitchValueNative(const StringPiece& switch_string) const;
+ std::string GetSwitchValueASCII(const std::string_view& switch_string) const;
+ FilePath GetSwitchValuePath(const std::string_view& switch_string) const;
+ StringType GetSwitchValueNative(const std::string_view& switch_string) const;
// Get a copy of all switches, along with their values.
const SwitchMap& GetSwitches() const { return switches_; }
@@ -215,7 +214,7 @@
#if defined(OS_WIN)
// Initialize by parsing the given command line string.
// The program name is assumed to be the first item in the string.
- void ParseFromString(const string16& command_line);
+ void ParseFromString(const std::u16string& command_line);
#endif
private:
diff --git a/base/containers/span.h b/base/containers/span.h
index c971861..20c7f15 100644
--- a/base/containers/span.h
+++ b/base/containers/span.h
@@ -88,8 +88,8 @@
// own the underlying memory, so care must be taken to ensure that a span does
// not outlive the backing store.
//
-// span is somewhat analogous to StringPiece, but with arbitrary element types,
-// allowing mutation if T is non-const.
+// span is somewhat analogous to std::string_view, but with arbitrary element
+// types, allowing mutation if T is non-const.
//
// span is implicitly convertible from C++ arrays, as well as most [1]
// container-like types that provide a data() and size() method (such as
diff --git a/base/environment.cc b/base/environment.cc
index 41951b7..427e3e5 100644
--- a/base/environment.cc
+++ b/base/environment.cc
@@ -6,10 +6,10 @@
#include <stddef.h>
+#include <string_view>
#include <vector>
#include "base/memory/ptr_util.h"
-#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "util/build_config.h"
@@ -26,7 +26,7 @@
class EnvironmentImpl : public Environment {
public:
- bool GetVar(StringPiece variable_name, std::string* result) override {
+ bool GetVar(std::string_view variable_name, std::string* result) override {
if (GetVarImpl(variable_name, result))
return true;
@@ -45,17 +45,17 @@
return GetVarImpl(alternate_case_var, result);
}
- bool SetVar(StringPiece variable_name,
+ bool SetVar(std::string_view variable_name,
const std::string& new_value) override {
return SetVarImpl(variable_name, new_value);
}
- bool UnSetVar(StringPiece variable_name) override {
+ bool UnSetVar(std::string_view variable_name) override {
return UnSetVarImpl(variable_name);
}
private:
- bool GetVarImpl(StringPiece variable_name, std::string* result) {
+ bool GetVarImpl(std::string_view variable_name, std::string* result) {
#if defined(OS_WIN)
DWORD value_length = ::GetEnvironmentVariable(
reinterpret_cast<LPCWSTR>(UTF8ToUTF16(variable_name).c_str()), nullptr,
@@ -81,7 +81,8 @@
#endif
}
- bool SetVarImpl(StringPiece variable_name, const std::string& new_value) {
+ bool SetVarImpl(std::string_view variable_name,
+ const std::string& new_value) {
#if defined(OS_WIN)
// On success, a nonzero value is returned.
return !!SetEnvironmentVariable(
@@ -93,7 +94,7 @@
#endif
}
- bool UnSetVarImpl(StringPiece variable_name) {
+ bool UnSetVarImpl(std::string_view variable_name) {
#if defined(OS_WIN)
// On success, a nonzero value is returned.
return !!SetEnvironmentVariable(
@@ -141,18 +142,19 @@
return std::make_unique<EnvironmentImpl>();
}
-bool Environment::HasVar(StringPiece variable_name) {
+bool Environment::HasVar(std::string_view variable_name) {
return GetVar(variable_name, nullptr);
}
#if defined(OS_WIN)
-string16 AlterEnvironment(const char16_t* env, const EnvironmentMap& changes) {
- string16 result;
+std::u16string AlterEnvironment(const char16_t* env,
+ const EnvironmentMap& changes) {
+ std::u16string result;
// First copy all unmodified values to the output.
size_t cur_env = 0;
- string16 key;
+ std::u16string key;
while (env[cur_env]) {
const char16_t* line = &env[cur_env];
size_t line_length = ParseEnvLine(line, &key);
diff --git a/base/environment.h b/base/environment.h
index 201b1a8..f9a2f55 100644
--- a/base/environment.h
+++ b/base/environment.h
@@ -8,9 +8,8 @@
#include <map>
#include <memory>
#include <string>
+#include <string_view>
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
#include "util/build_config.h"
namespace base {
@@ -32,22 +31,22 @@
// Gets an environment variable's value and stores it in |result|.
// Returns false if the key is unset.
- virtual bool GetVar(StringPiece variable_name, std::string* result) = 0;
+ virtual bool GetVar(std::string_view variable_name, std::string* result) = 0;
// Syntactic sugar for GetVar(variable_name, nullptr);
- virtual bool HasVar(StringPiece variable_name);
+ virtual bool HasVar(std::string_view variable_name);
// Returns true on success, otherwise returns false.
- virtual bool SetVar(StringPiece variable_name,
+ virtual bool SetVar(std::string_view variable_name,
const std::string& new_value) = 0;
// Returns true on success, otherwise returns false.
- virtual bool UnSetVar(StringPiece variable_name) = 0;
+ virtual bool UnSetVar(std::string_view variable_name) = 0;
};
#if defined(OS_WIN)
-typedef string16 NativeEnvironmentString;
+typedef std::u16string NativeEnvironmentString;
typedef std::map<NativeEnvironmentString, NativeEnvironmentString>
EnvironmentMap;
@@ -61,7 +60,8 @@
// which is a concatenated list of null-terminated 16-bit strings. The end is
// marked by a double-null terminator. The size of the returned string will
// include the terminators.
-string16 AlterEnvironment(const char16_t* env, const EnvironmentMap& changes);
+std::u16string AlterEnvironment(const char16_t* env,
+ const EnvironmentMap& changes);
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
diff --git a/base/files/file_path.cc b/base/files/file_path.cc
index 3ecb009..e546761 100644
--- a/base/files/file_path.cc
+++ b/base/files/file_path.cc
@@ -5,11 +5,12 @@
#include "base/files/file_path.h"
#include <string.h>
+
#include <algorithm>
+#include <string_view>
#include "base/logging.h"
#include "base/macros.h"
-#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "util/build_config.h"
@@ -28,7 +29,7 @@
namespace base {
using StringType = FilePath::StringType;
-using StringPieceType = FilePath::StringPieceType;
+using StringViewType = FilePath::StringViewType;
namespace {
@@ -42,7 +43,7 @@
// otherwise returns npos. This can only be true on Windows, when a pathname
// begins with a letter followed by a colon. On other platforms, this always
// returns npos.
-StringPieceType::size_type FindDriveLetter(StringPieceType path) {
+StringViewType::size_type FindDriveLetter(StringViewType path) {
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
// This is dependent on an ASCII-based character set, but that's a
// reasonable assumption. iswalpha can be too inclusive here.
@@ -56,25 +57,25 @@
}
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
-bool EqualDriveLetterCaseInsensitive(StringPieceType a, StringPieceType b) {
+bool EqualDriveLetterCaseInsensitive(StringViewType a, StringViewType b) {
size_t a_letter_pos = FindDriveLetter(a);
size_t b_letter_pos = FindDriveLetter(b);
if (a_letter_pos == StringType::npos || b_letter_pos == StringType::npos)
return a == b;
- StringPieceType a_letter(a.substr(0, a_letter_pos + 1));
- StringPieceType b_letter(b.substr(0, b_letter_pos + 1));
+ StringViewType a_letter(a.substr(0, a_letter_pos + 1));
+ StringViewType b_letter(b.substr(0, b_letter_pos + 1));
if (!StartsWith(a_letter, b_letter, CompareCase::INSENSITIVE_ASCII))
return false;
- StringPieceType a_rest(a.substr(a_letter_pos + 1));
- StringPieceType b_rest(b.substr(b_letter_pos + 1));
+ StringViewType a_rest(a.substr(a_letter_pos + 1));
+ StringViewType b_rest(b.substr(b_letter_pos + 1));
return a_rest == b_rest;
}
#endif // defined(FILE_PATH_USES_DRIVE_LETTERS)
-bool IsPathAbsolute(StringPieceType path) {
+bool IsPathAbsolute(StringViewType path) {
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
StringType::size_type letter = FindDriveLetter(path);
if (letter != StringType::npos) {
@@ -170,7 +171,7 @@
FilePath::FilePath(const FilePath& that) = default;
FilePath::FilePath(FilePath&& that) noexcept = default;
-FilePath::FilePath(StringPieceType path) {
+FilePath::FilePath(StringViewType path) {
path_.assign(path);
StringType::size_type nul_pos = path_.find(kStringTerminator);
if (nul_pos != StringType::npos)
@@ -392,7 +393,7 @@
return FilePath(path_.substr(0, dot));
}
-FilePath FilePath::InsertBeforeExtension(StringPieceType suffix) const {
+FilePath FilePath::InsertBeforeExtension(StringViewType suffix) const {
if (suffix.empty())
return FilePath(path_);
@@ -406,7 +407,7 @@
return FilePath(ret);
}
-FilePath FilePath::InsertBeforeExtensionASCII(StringPiece suffix) const {
+FilePath FilePath::InsertBeforeExtensionASCII(std::string_view suffix) const {
DCHECK(IsStringASCII(suffix));
#if defined(OS_WIN)
return InsertBeforeExtension(ASCIIToUTF16(suffix));
@@ -415,7 +416,7 @@
#endif
}
-FilePath FilePath::AddExtension(StringPieceType extension) const {
+FilePath FilePath::AddExtension(StringViewType extension) const {
if (IsEmptyOrSpecialCase(BaseName().value()))
return FilePath();
@@ -433,7 +434,7 @@
return FilePath(str);
}
-FilePath FilePath::ReplaceExtension(StringPieceType extension) const {
+FilePath FilePath::ReplaceExtension(StringViewType extension) const {
if (IsEmptyOrSpecialCase(BaseName().value()))
return FilePath();
@@ -450,14 +451,14 @@
return FilePath(str);
}
-FilePath FilePath::Append(StringPieceType component) const {
- StringPieceType appended = component;
+FilePath FilePath::Append(StringViewType component) const {
+ StringViewType appended = component;
StringType without_nuls;
StringType::size_type nul_pos = component.find(kStringTerminator);
- if (nul_pos != StringPieceType::npos) {
+ if (nul_pos != StringViewType::npos) {
without_nuls.assign(component.substr(0, nul_pos));
- appended = StringPieceType(without_nuls);
+ appended = StringViewType(without_nuls);
}
DCHECK(!IsPathAbsolute(appended));
@@ -498,7 +499,7 @@
return Append(component.value());
}
-FilePath FilePath::AppendASCII(StringPiece component) const {
+FilePath FilePath::AppendASCII(std::string_view component) const {
DCHECK(base::IsStringASCII(component));
#if defined(OS_WIN)
return Append(ASCIIToUTF16(component));
@@ -564,7 +565,7 @@
#if defined(OS_WIN)
-string16 FilePath::LossyDisplayName() const {
+std::u16string FilePath::LossyDisplayName() const {
return path_;
}
diff --git a/base/files/file_path.h b/base/files/file_path.h
index a8322c4..74fb674 100644
--- a/base/files/file_path.h
+++ b/base/files/file_path.h
@@ -106,12 +106,11 @@
#include <iosfwd>
#include <string>
+#include <string_view>
#include <vector>
#include "base/compiler_specific.h"
#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
#include "util/build_config.h"
// Windows-style drive letter support and pathname separator characters can be
@@ -153,7 +152,7 @@
#endif // OS_WIN
using CharType = StringType::value_type;
- using StringPieceType = std::basic_string_view<CharType>;
+ using StringViewType = std::basic_string_view<CharType>;
// Null-terminated array of separators used to separate components in
// hierarchical paths. Each character in this array is a valid separator,
@@ -175,7 +174,7 @@
FilePath();
FilePath(const FilePath& that);
- explicit FilePath(StringPieceType path);
+ explicit FilePath(StringViewType path);
~FilePath();
FilePath& operator=(const FilePath& that);
@@ -282,20 +281,20 @@
// path == "jojo.jpg" suffix == " (1)", returns "jojo (1).jpg"
// path == "C:\pics\jojo" suffix == " (1)", returns "C:\pics\jojo (1)"
// path == "C:\pics.old\jojo" suffix == " (1)", returns "C:\pics.old\jojo (1)"
- FilePath InsertBeforeExtension(StringPieceType suffix) const
+ FilePath InsertBeforeExtension(StringViewType suffix) const
WARN_UNUSED_RESULT;
- FilePath InsertBeforeExtensionASCII(StringPiece suffix) const
+ FilePath InsertBeforeExtensionASCII(std::string_view suffix) const
WARN_UNUSED_RESULT;
// Adds |extension| to |file_name|. Returns the current FilePath if
// |extension| is empty. Returns "" if BaseName() == "." or "..".
- FilePath AddExtension(StringPieceType extension) const WARN_UNUSED_RESULT;
+ FilePath AddExtension(StringViewType extension) const WARN_UNUSED_RESULT;
// Replaces the extension of |file_name| with |extension|. If |file_name|
// does not have an extension, then |extension| is added. If |extension| is
// empty, then the extension is removed from |file_name|.
// Returns "" if BaseName() == "." or "..".
- FilePath ReplaceExtension(StringPieceType extension) const WARN_UNUSED_RESULT;
+ FilePath ReplaceExtension(StringViewType extension) const WARN_UNUSED_RESULT;
// Returns a FilePath by appending a separator and the supplied path
// component to this object's path. Append takes care to avoid adding
@@ -303,7 +302,7 @@
// If this object's path is kCurrentDirectory, a new FilePath corresponding
// only to |component| is returned. |component| must be a relative path;
// it is an error to pass an absolute path.
- FilePath Append(StringPieceType component) const WARN_UNUSED_RESULT;
+ FilePath Append(StringViewType component) const WARN_UNUSED_RESULT;
FilePath Append(const FilePath& component) const WARN_UNUSED_RESULT;
// Although Windows StringType is std::u16string, since the encoding it uses
@@ -312,7 +311,7 @@
// Linux, although it can use any 8-bit encoding for paths, we assume that
// ASCII is a valid subset, regardless of the encoding, since many operating
// system paths will always be ASCII.
- FilePath AppendASCII(StringPiece component) const WARN_UNUSED_RESULT;
+ FilePath AppendASCII(std::string_view component) const WARN_UNUSED_RESULT;
// Returns true if this FilePath contains an absolute path. On Windows, an
// absolute path begins with either a drive letter specification followed by
@@ -338,8 +337,8 @@
// Return a Unicode human-readable version of this path.
// Warning: you can *not*, in general, go from a display name back to a real
// path. Only use this when displaying paths to users, not just when you
- // want to stuff a string16 into some other API.
- string16 LossyDisplayName() const;
+ // want to stuff a std::u16string into some other API.
+ std::u16string LossyDisplayName() const;
// Return the path as ASCII, or the empty string if the path is not ASCII.
// This should only be used for cases where the FilePath is representing a
diff --git a/base/files/file_util.cc b/base/files/file_util.cc
index 25b7aab..7043b75 100644
--- a/base/files/file_util.cc
+++ b/base/files/file_util.cc
@@ -11,11 +11,11 @@
#include <fstream>
#include <limits>
+#include <string_view>
#include "base/files/file_enumerator.h"
#include "base/files/file_path.h"
#include "base/logging.h"
-#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
diff --git a/base/files/file_util.h b/base/files/file_util.h
index e22f40f..0478c91 100644
--- a/base/files/file_util.h
+++ b/base/files/file_util.h
@@ -23,7 +23,6 @@
#include "base/files/file.h"
#include "base/files/file_path.h"
-#include "base/strings/string16.h"
#include "util/build_config.h"
#if defined(OS_WIN)
diff --git a/base/files/file_util_posix.cc b/base/files/file_util_posix.cc
index 0749ac9..a5822f1 100644
--- a/base/files/file_util_posix.cc
+++ b/base/files/file_util_posix.cc
@@ -183,7 +183,7 @@
// Appends |mode_char| to |mode| before the optional character set encoding; see
// https://www.gnu.org/software/libc/manual/html_node/Opening-Streams.html for
// details.
-std::string AppendModeCharacter(StringPiece mode, char mode_char) {
+std::string AppendModeCharacter(std::string_view mode, char mode_char) {
std::string result(mode);
size_t comma_pos = result.find(',');
result.insert(comma_pos == std::string::npos ? result.length() : comma_pos, 1,
@@ -394,7 +394,7 @@
return false;
}
- for (const StringPiece& cur_path :
+ for (const std::string_view& cur_path :
SplitStringPiece(path, ":", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY)) {
FilePath file(cur_path);
int permissions;
diff --git a/base/files/file_util_win.cc b/base/files/file_util_win.cc
index 8fba87a..3863f72 100644
--- a/base/files/file_util_win.cc
+++ b/base/files/file_util_win.cc
@@ -18,13 +18,13 @@
#include <algorithm>
#include <limits>
#include <string>
+#include <string_view>
#include "base/files/file_enumerator.h"
#include "base/files/file_path.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
@@ -86,9 +86,9 @@
// Appends |mode_char| to |mode| before the optional character set encoding; see
// https://msdn.microsoft.com/library/yeby3zcb.aspx for details.
-void AppendModeCharacter(base::char16 mode_char, base::string16* mode) {
+void AppendModeCharacter(char16_t mode_char, std::u16string* mode) {
size_t comma_pos = mode->find(L',');
- mode->insert(comma_pos == base::string16::npos ? mode->length() : comma_pos,
+ mode->insert(comma_pos == std::u16string::npos ? mode->length() : comma_pos,
1, mode_char);
}
@@ -195,7 +195,7 @@
bool DeleteFile(const FilePath& path, bool recursive) {
static constexpr char kRecursive[] = "DeleteFile.Recursive";
static constexpr char kNonRecursive[] = "DeleteFile.NonRecursive";
- const StringPiece operation(recursive ? kRecursive : kNonRecursive);
+ const std::string_view operation(recursive ? kRecursive : kNonRecursive);
// Metrics for delete failures tracked in https://crbug.com/599084. Delete may
// fail for a number of reasons. Log some metrics relating to failures in the
@@ -359,7 +359,7 @@
for (int count = 0; count < 50; ++count) {
// Try create a new temporary directory with random generated name. If
// the one exists, keep trying another path name until we reach some limit.
- string16 new_dir_name;
+ std::u16string new_dir_name;
new_dir_name.assign(prefix);
new_dir_name.append(IntToString16(::GetCurrentProcessId()));
new_dir_name.push_back('_');
@@ -578,7 +578,7 @@
DCHECK(
strchr(mode, 'N') == nullptr ||
(strchr(mode, ',') != nullptr && strchr(mode, 'N') > strchr(mode, ',')));
- string16 w_mode = ASCIIToUTF16(mode);
+ std::u16string w_mode = ASCIIToUTF16(mode);
AppendModeCharacter(L'N', &w_mode);
return _wfsopen(ToWCharT(&filename.value()), ToWCharT(&w_mode), _SH_DENYNO);
}
diff --git a/base/json/json_parser.cc b/base/json/json_parser.cc
index 713f692..eac52a6 100644
--- a/base/json/json_parser.cc
+++ b/base/json/json_parser.cc
@@ -5,6 +5,7 @@
#include "base/json/json_parser.h"
#include <cmath>
+#include <string_view>
#include <utility>
#include <vector>
@@ -12,7 +13,6 @@
#include "base/macros.h"
#include "base/numerics/safe_conversions.h"
#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversion_utils.h"
@@ -68,7 +68,7 @@
JSONParser::~JSONParser() = default;
-Optional<Value> JSONParser::Parse(StringPiece input) {
+Optional<Value> JSONParser::Parse(std::string_view input) {
input_ = input;
index_ = 0;
line_number_ = 1;
@@ -163,30 +163,30 @@
// JSONParser private //////////////////////////////////////////////////////////
-Optional<StringPiece> JSONParser::PeekChars(int count) {
+Optional<std::string_view> JSONParser::PeekChars(int count) {
if (static_cast<size_t>(index_) + count > input_.length())
return nullopt;
- // Using StringPiece::substr() is significantly slower (according to
+ // Using std::string_view::substr() is significantly slower (according to
// base_perftests) than constructing a substring manually.
- return StringPiece(input_.data() + index_, count);
+ return std::string_view(input_.data() + index_, count);
}
Optional<char> JSONParser::PeekChar() {
- Optional<StringPiece> chars = PeekChars(1);
+ Optional<std::string_view> chars = PeekChars(1);
if (chars)
return (*chars)[0];
return nullopt;
}
-Optional<StringPiece> JSONParser::ConsumeChars(int count) {
- Optional<StringPiece> chars = PeekChars(count);
+Optional<std::string_view> JSONParser::ConsumeChars(int count) {
+ Optional<std::string_view> chars = PeekChars(count);
if (chars)
index_ += count;
return chars;
}
Optional<char> JSONParser::ConsumeChar() {
- Optional<StringPiece> chars = ConsumeChars(1);
+ Optional<std::string_view> chars = ConsumeChars(1);
if (chars)
return (*chars)[0];
return nullopt;
@@ -268,7 +268,7 @@
}
bool JSONParser::EatComment() {
- Optional<StringPiece> comment_start = ConsumeChars(2);
+ Optional<std::string_view> comment_start = ConsumeChars(2);
if (!comment_start)
return false;
@@ -444,7 +444,7 @@
return false;
}
- // StringBuilder will internally build a StringPiece unless a UTF-16
+ // StringBuilder will internally build a std::string_view unless a UTF-16
// conversion occurs, at which point it will perform a copy into a
// std::string.
StringBuilder string(pos());
@@ -475,12 +475,12 @@
} else {
// And if it is an escape sequence, the input string will be adjusted
// (either by combining the two characters of an encoded escape sequence,
- // or with a UTF conversion), so using StringPiece isn't possible -- force
- // a conversion.
+ // or with a UTF conversion), so using std::string_view isn't possible --
+ // force a conversion.
string.Convert();
// Read past the escape '\' and ensure there's a character following.
- Optional<StringPiece> escape_sequence = ConsumeChars(2);
+ Optional<std::string_view> escape_sequence = ConsumeChars(2);
if (!escape_sequence) {
ReportError(JSONReader::JSON_INVALID_ESCAPE, 0);
return false;
@@ -558,7 +558,7 @@
// Entry is at the first X in \uXXXX.
bool JSONParser::DecodeUTF16(uint32_t* out_code_point) {
- Optional<StringPiece> escape_sequence = ConsumeChars(4);
+ Optional<std::string_view> escape_sequence = ConsumeChars(4);
if (!escape_sequence)
return false;
@@ -671,7 +671,7 @@
index_ = exit_index;
- StringPiece num_string(num_start, end_index - start_index);
+ std::string_view num_string(num_start, end_index - start_index);
int num_int;
if (StringToInt(num_string, &num_int))
@@ -717,7 +717,7 @@
}
}
-bool JSONParser::ConsumeIfMatch(StringPiece match) {
+bool JSONParser::ConsumeIfMatch(std::string_view match) {
if (match == PeekChars(match.size())) {
ConsumeChars(match.size());
return true;
diff --git a/base/json/json_parser.h b/base/json/json_parser.h
index 1289560..6bd61a4 100644
--- a/base/json/json_parser.h
+++ b/base/json/json_parser.h
@@ -10,13 +10,13 @@
#include <memory>
#include <string>
+#include <string_view>
#include "base/compiler_specific.h"
#include "base/gtest_prod_util.h"
#include "base/json/json_reader.h"
#include "base/macros.h"
#include "base/optional.h"
-#include "base/strings/string_piece.h"
namespace base {
@@ -49,7 +49,7 @@
// result as a Value.
// Wrap this in base::FooValue::From() to check the Value is of type Foo and
// convert to a FooValue at the same time.
- Optional<Value> Parse(StringPiece input);
+ Optional<Value> Parse(std::string_view input);
// Returns the error code.
JSONReader::JsonParseError error_code() const;
@@ -83,7 +83,7 @@
};
// A helper class used for parsing strings. One optimization performed is to
- // create base::Value with a StringPiece to avoid unnecessary std::string
+ // create base::Value with a std::string_view to avoid unnecessary std::string
// copies. This is not possible if the input string needs to be decoded from
// UTF-16 to UTF-8, or if an escape sequence causes characters to be skipped.
// This class centralizes that logic.
@@ -104,9 +104,9 @@
// converted, or by appending the UTF8 bytes for the code point.
void Append(uint32_t point);
- // Converts the builder from its default StringPiece to a full std::string,
- // performing a copy. Once a builder is converted, it cannot be made a
- // StringPiece again.
+ // Converts the builder from its default std::string_view to a full
+ // std::string, performing a copy. Once a builder is converted, it cannot be
+ // made a std::string_view again.
void Convert();
// Returns the builder as a string, invalidating all state. This allows
@@ -128,14 +128,14 @@
// Returns the next |count| bytes of the input stream, or nullopt if fewer
// than |count| bytes remain.
- Optional<StringPiece> PeekChars(int count);
+ Optional<std::string_view> PeekChars(int count);
// Calls PeekChars() with a |count| of 1.
Optional<char> PeekChar();
// Returns the next |count| bytes of the input stream, or nullopt if fewer
// than |count| bytes remain, and advances the parser position by |count|.
- Optional<StringPiece> ConsumeChars(int count);
+ Optional<std::string_view> ConsumeChars(int count);
// Calls ConsumeChars() with a |count| of 1.
Optional<char> ConsumeChar();
@@ -198,7 +198,7 @@
// consumed at the current parser position. Returns false if there are fewer
// than |match|-length bytes or if the sequence does not match, and the
// parser state is unchanged.
- bool ConsumeIfMatch(StringPiece match);
+ bool ConsumeIfMatch(std::string_view match);
// Sets the error information to |code| at the current column, based on
// |index_| and |index_last_line_|, with an optional positive/negative
@@ -218,7 +218,7 @@
const int max_depth_;
// The input stream being parsed. Note: Not guaranteed to NUL-terminated.
- StringPiece input_;
+ std::string_view input_;
// The index in the input stream to which the parser is wound.
int index_;
diff --git a/base/json/json_reader.cc b/base/json/json_reader.cc
index 3d5475e..d7eb7d9 100644
--- a/base/json/json_reader.cc
+++ b/base/json/json_reader.cc
@@ -41,7 +41,7 @@
JSONReader::~JSONReader() = default;
// static
-std::unique_ptr<Value> JSONReader::Read(StringPiece json,
+std::unique_ptr<Value> JSONReader::Read(std::string_view json,
int options,
int max_depth) {
internal::JSONParser parser(options, max_depth);
@@ -51,7 +51,7 @@
// static
std::unique_ptr<Value> JSONReader::ReadAndReturnError(
- StringPiece json,
+ std::string_view json,
int options,
int* error_code_out,
std::string* error_msg_out,
@@ -103,7 +103,7 @@
return std::string();
}
-std::unique_ptr<Value> JSONReader::ReadToValue(StringPiece json) {
+std::unique_ptr<Value> JSONReader::ReadToValue(std::string_view json) {
Optional<Value> value = parser_->Parse(json);
return value ? std::make_unique<Value>(std::move(*value)) : nullptr;
}
diff --git a/base/json/json_reader.h b/base/json/json_reader.h
index c4f7c8f..c454981 100644
--- a/base/json/json_reader.h
+++ b/base/json/json_reader.h
@@ -30,8 +30,7 @@
#include <memory>
#include <string>
-
-#include "base/strings/string_piece.h"
+#include <string_view>
namespace base {
@@ -94,7 +93,7 @@
// If |json| is not a properly formed JSON string, returns nullptr.
// Wrap this in base::FooValue::From() to check the Value is of type Foo and
// convert to a FooValue at the same time.
- static std::unique_ptr<Value> Read(StringPiece json,
+ static std::unique_ptr<Value> Read(std::string_view json,
int options = JSON_PARSE_RFC,
int max_depth = kStackMaxDepth);
@@ -103,7 +102,7 @@
// an error code and a formatted error message (including error location if
// appropriate). Otherwise, they will be unmodified.
static std::unique_ptr<Value> ReadAndReturnError(
- StringPiece json,
+ std::string_view json,
int options, // JSONParserOptions
int* error_code_out,
std::string* error_msg_out,
@@ -115,7 +114,7 @@
static std::string ErrorCodeToString(JsonParseError error_code);
// Non-static version of Read() above.
- std::unique_ptr<Value> ReadToValue(StringPiece json);
+ std::unique_ptr<Value> ReadToValue(std::string_view json);
// Returns the error code if the last call to ReadToValue() failed.
// Returns JSON_NO_ERROR otherwise.
diff --git a/base/json/json_value_converter.cc b/base/json/json_value_converter.cc
index 55506e6..ee7b094 100644
--- a/base/json/json_value_converter.cc
+++ b/base/json/json_value_converter.cc
@@ -17,8 +17,8 @@
return value.GetAsString(field);
}
-bool BasicValueConverter<string16>::Convert(const base::Value& value,
- string16* field) const {
+bool BasicValueConverter<std::u16string>::Convert(const base::Value& value,
+ std::u16string* field) const {
return value.GetAsString(field);
}
diff --git a/base/json/json_value_converter.h b/base/json/json_value_converter.h
index d91bead..f3030f2 100644
--- a/base/json/json_value_converter.h
+++ b/base/json/json_value_converter.h
@@ -9,13 +9,12 @@
#include <memory>
#include <string>
+#include <string_view>
#include <vector>
#include "base/logging.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
#include "base/values.h"
// JSONValueConverter converts a JSON value into a C++ struct in a
@@ -70,8 +69,8 @@
//
// Sometimes JSON format uses string representations for other types such
// like enum, timestamp, or URL. You can use RegisterCustomField method
-// and specify a function to convert a StringPiece to your type.
-// bool ConvertFunc(StringPiece s, YourEnum* result) {
+// and specify a function to convert a std::string_view to your type.
+// bool ConvertFunc(std::string_view s, YourEnum* result) {
// // do something and return true if succeed...
// }
// struct Message {
@@ -158,11 +157,12 @@
};
template <>
-class BasicValueConverter<string16> : public ValueConverter<string16> {
+class BasicValueConverter<std::u16string>
+ : public ValueConverter<std::u16string> {
public:
BasicValueConverter() = default;
- bool Convert(const base::Value& value, string16* field) const override;
+ bool Convert(const base::Value& value, std::u16string* field) const override;
private:
DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
@@ -211,7 +211,7 @@
template <typename FieldType>
class CustomFieldConverter : public ValueConverter<FieldType> {
public:
- typedef bool (*ConvertFunc)(StringPiece value, FieldType* field);
+ typedef bool (*ConvertFunc)(std::string_view value, FieldType* field);
explicit CustomFieldConverter(ConvertFunc convert_func)
: convert_func_(convert_func) {}
@@ -367,10 +367,11 @@
}
void RegisterStringField(const std::string& field_name,
- string16 StructType::*field) {
+ std::u16string StructType::*field) {
fields_.push_back(
- std::make_unique<internal::FieldConverter<StructType, string16>>(
- field_name, field, new internal::BasicValueConverter<string16>));
+ std::make_unique<internal::FieldConverter<StructType, std::u16string>>(
+ field_name, field,
+ new internal::BasicValueConverter<std::u16string>));
}
void RegisterBoolField(const std::string& field_name,
@@ -398,7 +399,7 @@
template <typename FieldType>
void RegisterCustomField(const std::string& field_name,
FieldType StructType::*field,
- bool (*convert_func)(StringPiece, FieldType*)) {
+ bool (*convert_func)(std::string_view, FieldType*)) {
fields_.push_back(
std::make_unique<internal::FieldConverter<StructType, FieldType>>(
field_name, field,
@@ -436,10 +437,12 @@
void RegisterRepeatedString(
const std::string& field_name,
- std::vector<std::unique_ptr<string16>> StructType::*field) {
- fields_.push_back(std::make_unique<internal::FieldConverter<
- StructType, std::vector<std::unique_ptr<string16>>>>(
- field_name, field, new internal::RepeatedValueConverter<string16>));
+ std::vector<std::unique_ptr<std::u16string>> StructType::*field) {
+ fields_.push_back(
+ std::make_unique<internal::FieldConverter<
+ StructType, std::vector<std::unique_ptr<std::u16string>>>>(
+ field_name, field,
+ new internal::RepeatedValueConverter<std::u16string>));
}
void RegisterRepeatedDouble(
diff --git a/base/json/string_escape.cc b/base/json/string_escape.cc
index 471a9d3..ea674f5 100644
--- a/base/json/string_escape.cc
+++ b/base/json/string_escape.cc
@@ -116,38 +116,41 @@
} // namespace
-bool EscapeJSONString(StringPiece str, bool put_in_quotes, std::string* dest) {
- return EscapeJSONStringImpl(str, put_in_quotes, dest);
-}
-
-bool EscapeJSONString(StringPiece16 str,
+bool EscapeJSONString(std::string_view str,
bool put_in_quotes,
std::string* dest) {
return EscapeJSONStringImpl(str, put_in_quotes, dest);
}
-std::string GetQuotedJSONString(StringPiece str) {
+bool EscapeJSONString(std::u16string_view str,
+ bool put_in_quotes,
+ std::string* dest) {
+ return EscapeJSONStringImpl(str, put_in_quotes, dest);
+}
+
+std::string GetQuotedJSONString(std::string_view str) {
std::string dest;
bool ok = EscapeJSONStringImpl(str, true, &dest);
DCHECK(ok);
return dest;
}
-std::string GetQuotedJSONString(StringPiece16 str) {
+std::string GetQuotedJSONString(std::u16string_view str) {
std::string dest;
bool ok = EscapeJSONStringImpl(str, true, &dest);
DCHECK(ok);
return dest;
}
-std::string EscapeBytesAsInvalidJSONString(StringPiece str,
+std::string EscapeBytesAsInvalidJSONString(std::string_view str,
bool put_in_quotes) {
std::string dest;
if (put_in_quotes)
dest.push_back('"');
- for (StringPiece::const_iterator it = str.begin(); it != str.end(); ++it) {
+ for (std::string_view::const_iterator it = str.begin(); it != str.end();
+ ++it) {
unsigned char c = *it;
if (EscapeSpecialCodePoint(c, &dest))
continue;
diff --git a/base/json/string_escape.h b/base/json/string_escape.h
index d318b6a..ada5179 100644
--- a/base/json/string_escape.h
+++ b/base/json/string_escape.h
@@ -8,8 +8,7 @@
#define BASE_JSON_STRING_ESCAPE_H_
#include <string>
-
-#include "base/strings/string_piece.h"
+#include <string_view>
namespace base {
@@ -25,17 +24,21 @@
//
// If |put_in_quotes| is true, then a leading and trailing double-quote mark
// will be appended to |dest| as well.
-bool EscapeJSONString(StringPiece str, bool put_in_quotes, std::string* dest);
+bool EscapeJSONString(std::string_view str,
+ bool put_in_quotes,
+ std::string* dest);
-// Performs a similar function to the UTF-8 StringPiece version above,
+// Performs a similar function to the UTF-8 std::string_view version above,
// converting UTF-16 code units to UTF-8 code units and escaping non-printing
// control characters. On return, |dest| will contain a valid UTF-8 JSON string.
-bool EscapeJSONString(StringPiece16 str, bool put_in_quotes, std::string* dest);
+bool EscapeJSONString(std::u16string_view str,
+ bool put_in_quotes,
+ std::string* dest);
// Helper functions that wrap the above two functions but return the value
// instead of appending. |put_in_quotes| is always true.
-std::string GetQuotedJSONString(StringPiece str);
-std::string GetQuotedJSONString(StringPiece16 str);
+std::string GetQuotedJSONString(std::string_view str);
+std::string GetQuotedJSONString(std::u16string_view str);
// Given an arbitrary byte string |str|, this will escape all non-ASCII bytes
// as \uXXXX escape sequences. This function is *NOT* meant to be used with
@@ -48,7 +51,8 @@
//
// The output of this function takes the *appearance* of JSON but is not in
// fact valid according to RFC 4627.
-std::string EscapeBytesAsInvalidJSONString(StringPiece str, bool put_in_quotes);
+std::string EscapeBytesAsInvalidJSONString(std::string_view str,
+ bool put_in_quotes);
} // namespace base
diff --git a/base/logging.cc b/base/logging.cc
index 1144d61..16449ee 100644
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -42,12 +42,12 @@
#include <iomanip>
#include <ostream>
#include <string>
+#include <string_view>
#include <utility>
#include "base/callback.h"
#include "base/containers/stack.h"
#include "base/posix/eintr_wrapper.h"
-#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
@@ -188,9 +188,9 @@
// writes the common header info to the stream
void LogMessage::Init(const char* file, int line) {
- base::StringPiece filename(file);
+ std::string_view filename(file);
size_t last_slash_pos = filename.find_last_of("\\/");
- if (last_slash_pos != base::StringPiece::npos)
+ if (last_slash_pos != std::string_view::npos)
filename.remove_prefix(last_slash_pos + 1);
// TODO(darin): It might be nice if the columns were fixed width.
diff --git a/base/logging.h b/base/logging.h
index cba1c55..78c0861 100644
--- a/base/logging.h
+++ b/base/logging.h
@@ -11,13 +11,13 @@
#include <cstring>
#include <sstream>
#include <string>
+#include <string_view>
#include <type_traits>
#include <utility>
#include "base/callback_forward.h"
#include "base/compiler_specific.h"
#include "base/macros.h"
-#include "base/strings/string_piece.h"
#include "base/template_util.h"
#include "util/build_config.h"
diff --git a/base/md5.cc b/base/md5.cc
index 0b50e56..4fcab55 100644
--- a/base/md5.cc
+++ b/base/md5.cc
@@ -169,7 +169,7 @@
* Update context to reflect the concatenation of another buffer full
* of bytes.
*/
-void MD5Update(MD5Context* context, const StringPiece& data) {
+void MD5Update(MD5Context* context, const std::string_view& data) {
struct Context* ctx = reinterpret_cast<struct Context*>(context);
const uint8_t* buf = reinterpret_cast<const uint8_t*>(data.data());
size_t len = data.size();
@@ -287,11 +287,12 @@
void MD5Sum(const void* data, size_t length, MD5Digest* digest) {
MD5Context ctx;
MD5Init(&ctx);
- MD5Update(&ctx, StringPiece(reinterpret_cast<const char*>(data), length));
+ MD5Update(&ctx,
+ std::string_view(reinterpret_cast<const char*>(data), length));
MD5Final(digest, &ctx);
}
-std::string MD5String(const StringPiece& str) {
+std::string MD5String(const std::string_view& str) {
MD5Digest digest;
MD5Sum(str.data(), str.length(), &digest);
return MD5DigestToBase16(digest);
diff --git a/base/md5.h b/base/md5.h
index 802645c..d25b2fc 100644
--- a/base/md5.h
+++ b/base/md5.h
@@ -9,8 +9,7 @@
#include <stdint.h>
#include <string>
-
-#include "base/strings/string_piece.h"
+#include <string_view>
namespace base {
@@ -50,10 +49,10 @@
// MD5Update().
void MD5Init(MD5Context* context);
-// For the given buffer of |data| as a StringPiece, updates the given MD5
+// For the given buffer of |data| as a std::string_view, updates the given MD5
// context with the sum of the data. You can call this any number of times
// during the computation, except that MD5Init() must have been called first.
-void MD5Update(MD5Context* context, const StringPiece& data);
+void MD5Update(MD5Context* context, const std::string_view& data);
// Finalizes the MD5 operation and fills the buffer with the digest.
void MD5Final(MD5Digest* digest, MD5Context* context);
@@ -71,7 +70,7 @@
void MD5Sum(const void* data, size_t length, MD5Digest* digest);
// Returns the MD5 (in hexadecimal) of a string.
-std::string MD5String(const StringPiece& str);
+std::string MD5String(const std::string_view& str);
} // namespace base
diff --git a/base/strings/char_traits.h b/base/strings/char_traits.h
index b193e21..c432849 100644
--- a/base/strings/char_traits.h
+++ b/base/strings/char_traits.h
@@ -13,7 +13,7 @@
// constexpr version of http://en.cppreference.com/w/cpp/string/char_traits.
// This currently just implements the bits needed to support a (mostly)
-// constexpr StringPiece.
+// constexpr std::string_view.
//
// TODO(dcheng): Once we switch to C++17, most methods will become constexpr and
// we can switch over to using the one in the standard library.
diff --git a/base/strings/string16.h b/base/strings/string16.h
deleted file mode 100644
index a8e6ae3..0000000
--- a/base/strings/string16.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_STRING16_H_
-#define BASE_STRINGS_STRING16_H_
-
-#include <string>
-
-namespace base {
-
-// Temporary definitions. These should be removed and code using the standard
-// ones.
-using char16 = char16_t;
-using string16 = std::u16string;
-
-} // namespace base
-
-#endif // BASE_STRINGS_STRING16_H_
diff --git a/base/strings/string_number_conversions.cc b/base/strings/string_number_conversions.cc
index 5f94a56..9156fa3 100644
--- a/base/strings/string_number_conversions.cc
+++ b/base/strings/string_number_conversions.cc
@@ -270,38 +270,38 @@
class BaseHexIteratorRangeToUInt64Traits
: public BaseIteratorRangeToNumberTraits<ITERATOR, uint64_t, 16> {};
-typedef BaseHexIteratorRangeToIntTraits<StringPiece::const_iterator>
+typedef BaseHexIteratorRangeToIntTraits<std::string_view::const_iterator>
HexIteratorRangeToIntTraits;
-typedef BaseHexIteratorRangeToUIntTraits<StringPiece::const_iterator>
+typedef BaseHexIteratorRangeToUIntTraits<std::string_view::const_iterator>
HexIteratorRangeToUIntTraits;
-typedef BaseHexIteratorRangeToInt64Traits<StringPiece::const_iterator>
+typedef BaseHexIteratorRangeToInt64Traits<std::string_view::const_iterator>
HexIteratorRangeToInt64Traits;
-typedef BaseHexIteratorRangeToUInt64Traits<StringPiece::const_iterator>
+typedef BaseHexIteratorRangeToUInt64Traits<std::string_view::const_iterator>
HexIteratorRangeToUInt64Traits;
template <typename VALUE, int BASE>
class StringPieceToNumberTraits
- : public BaseIteratorRangeToNumberTraits<StringPiece::const_iterator,
+ : public BaseIteratorRangeToNumberTraits<std::string_view::const_iterator,
VALUE,
BASE> {};
template <typename VALUE>
-bool StringToIntImpl(StringPiece input, VALUE* output) {
+bool StringToIntImpl(std::string_view input, VALUE* output) {
return IteratorRangeToNumber<StringPieceToNumberTraits<VALUE, 10>>::Invoke(
input.begin(), input.end(), output);
}
template <typename VALUE, int BASE>
-class StringPiece16ToNumberTraits
- : public BaseIteratorRangeToNumberTraits<StringPiece16::const_iterator,
- VALUE,
- BASE> {};
+class StringPiece16ToNumberTraits : public BaseIteratorRangeToNumberTraits<
+ std::u16string_view::const_iterator,
+ VALUE,
+ BASE> {};
template <typename VALUE>
-bool String16ToIntImpl(StringPiece16 input, VALUE* output) {
+bool String16ToIntImpl(std::u16string_view input, VALUE* output) {
return IteratorRangeToNumber<StringPiece16ToNumberTraits<VALUE, 10>>::Invoke(
input.begin(), input.end(), output);
}
@@ -312,87 +312,87 @@
return IntToStringT<std::string, int>::IntToString(value);
}
-string16 NumberToString16(int value) {
- return IntToStringT<string16, int>::IntToString(value);
+std::u16string NumberToString16(int value) {
+ return IntToStringT<std::u16string, int>::IntToString(value);
}
std::string NumberToString(unsigned value) {
return IntToStringT<std::string, unsigned>::IntToString(value);
}
-string16 NumberToString16(unsigned value) {
- return IntToStringT<string16, unsigned>::IntToString(value);
+std::u16string NumberToString16(unsigned value) {
+ return IntToStringT<std::u16string, unsigned>::IntToString(value);
}
std::string NumberToString(long value) {
return IntToStringT<std::string, long>::IntToString(value);
}
-string16 NumberToString16(long value) {
- return IntToStringT<string16, long>::IntToString(value);
+std::u16string NumberToString16(long value) {
+ return IntToStringT<std::u16string, long>::IntToString(value);
}
std::string NumberToString(unsigned long value) {
return IntToStringT<std::string, unsigned long>::IntToString(value);
}
-string16 NumberToString16(unsigned long value) {
- return IntToStringT<string16, unsigned long>::IntToString(value);
+std::u16string NumberToString16(unsigned long value) {
+ return IntToStringT<std::u16string, unsigned long>::IntToString(value);
}
std::string NumberToString(long long value) {
return IntToStringT<std::string, long long>::IntToString(value);
}
-string16 NumberToString16(long long value) {
- return IntToStringT<string16, long long>::IntToString(value);
+std::u16string NumberToString16(long long value) {
+ return IntToStringT<std::u16string, long long>::IntToString(value);
}
std::string NumberToString(unsigned long long value) {
return IntToStringT<std::string, unsigned long long>::IntToString(value);
}
-string16 NumberToString16(unsigned long long value) {
- return IntToStringT<string16, unsigned long long>::IntToString(value);
+std::u16string NumberToString16(unsigned long long value) {
+ return IntToStringT<std::u16string, unsigned long long>::IntToString(value);
}
-bool StringToInt(StringPiece input, int* output) {
+bool StringToInt(std::string_view input, int* output) {
return StringToIntImpl(input, output);
}
-bool StringToInt(StringPiece16 input, int* output) {
+bool StringToInt(std::u16string_view input, int* output) {
return String16ToIntImpl(input, output);
}
-bool StringToUint(StringPiece input, unsigned* output) {
+bool StringToUint(std::string_view input, unsigned* output) {
return StringToIntImpl(input, output);
}
-bool StringToUint(StringPiece16 input, unsigned* output) {
+bool StringToUint(std::u16string_view input, unsigned* output) {
return String16ToIntImpl(input, output);
}
-bool StringToInt64(StringPiece input, int64_t* output) {
+bool StringToInt64(std::string_view input, int64_t* output) {
return StringToIntImpl(input, output);
}
-bool StringToInt64(StringPiece16 input, int64_t* output) {
+bool StringToInt64(std::u16string_view input, int64_t* output) {
return String16ToIntImpl(input, output);
}
-bool StringToUint64(StringPiece input, uint64_t* output) {
+bool StringToUint64(std::string_view input, uint64_t* output) {
return StringToIntImpl(input, output);
}
-bool StringToUint64(StringPiece16 input, uint64_t* output) {
+bool StringToUint64(std::u16string_view input, uint64_t* output) {
return String16ToIntImpl(input, output);
}
-bool StringToSizeT(StringPiece input, size_t* output) {
+bool StringToSizeT(std::string_view input, size_t* output) {
return StringToIntImpl(input, output);
}
-bool StringToSizeT(StringPiece16 input, size_t* output) {
+bool StringToSizeT(std::u16string_view input, size_t* output) {
return String16ToIntImpl(input, output);
}
@@ -418,27 +418,27 @@
return ret;
}
-bool HexStringToInt(StringPiece input, int* output) {
+bool HexStringToInt(std::string_view input, int* output) {
return IteratorRangeToNumber<HexIteratorRangeToIntTraits>::Invoke(
input.begin(), input.end(), output);
}
-bool HexStringToUInt(StringPiece input, uint32_t* output) {
+bool HexStringToUInt(std::string_view input, uint32_t* output) {
return IteratorRangeToNumber<HexIteratorRangeToUIntTraits>::Invoke(
input.begin(), input.end(), output);
}
-bool HexStringToInt64(StringPiece input, int64_t* output) {
+bool HexStringToInt64(std::string_view input, int64_t* output) {
return IteratorRangeToNumber<HexIteratorRangeToInt64Traits>::Invoke(
input.begin(), input.end(), output);
}
-bool HexStringToUInt64(StringPiece input, uint64_t* output) {
+bool HexStringToUInt64(std::string_view input, uint64_t* output) {
return IteratorRangeToNumber<HexIteratorRangeToUInt64Traits>::Invoke(
input.begin(), input.end(), output);
}
-bool HexStringToBytes(StringPiece input, std::vector<uint8_t>* output) {
+bool HexStringToBytes(std::string_view input, std::vector<uint8_t>* output) {
DCHECK_EQ(output->size(), 0u);
size_t count = input.size();
if (count == 0 || (count % 2) != 0)
diff --git a/base/strings/string_number_conversions.h b/base/strings/string_number_conversions.h
index 8ffdd36..81360a0 100644
--- a/base/strings/string_number_conversions.h
+++ b/base/strings/string_number_conversions.h
@@ -9,10 +9,9 @@
#include <stdint.h>
#include <string>
+#include <string_view>
#include <vector>
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
#include "util/build_config.h"
namespace base {
@@ -21,17 +20,17 @@
// Ignores locale! see warning above.
std::string NumberToString(int value);
-string16 NumberToString16(int value);
+std::u16string NumberToString16(int value);
std::string NumberToString(unsigned int value);
-string16 NumberToString16(unsigned int value);
+std::u16string NumberToString16(unsigned int value);
std::string NumberToString(long value);
-string16 NumberToString16(long value);
+std::u16string NumberToString16(long value);
std::string NumberToString(unsigned long value);
-string16 NumberToString16(unsigned long value);
+std::u16string NumberToString16(unsigned long value);
std::string NumberToString(long long value);
-string16 NumberToString16(long long value);
+std::u16string NumberToString16(long long value);
std::string NumberToString(unsigned long long value);
-string16 NumberToString16(unsigned long long value);
+std::u16string NumberToString16(unsigned long long value);
// Type-specific naming for backwards compatibility.
//
@@ -40,19 +39,19 @@
inline std::string IntToString(int value) {
return NumberToString(value);
}
-inline string16 IntToString16(int value) {
+inline std::u16string IntToString16(int value) {
return NumberToString16(value);
}
inline std::string UintToString(unsigned value) {
return NumberToString(value);
}
-inline string16 UintToString16(unsigned value) {
+inline std::u16string UintToString16(unsigned value) {
return NumberToString16(value);
}
inline std::string Int64ToString(int64_t value) {
return NumberToString(value);
}
-inline string16 Int64ToString16(int64_t value) {
+inline std::u16string Int64ToString16(int64_t value) {
return NumberToString16(value);
}
@@ -74,20 +73,20 @@
// - Empty string. |*output| will be set to 0.
// WARNING: Will write to |output| even when returning false.
// Read the comments above carefully.
-bool StringToInt(StringPiece input, int* output);
-bool StringToInt(StringPiece16 input, int* output);
+bool StringToInt(std::string_view input, int* output);
+bool StringToInt(std::u16string_view input, int* output);
-bool StringToUint(StringPiece input, unsigned* output);
-bool StringToUint(StringPiece16 input, unsigned* output);
+bool StringToUint(std::string_view input, unsigned* output);
+bool StringToUint(std::u16string_view input, unsigned* output);
-bool StringToInt64(StringPiece input, int64_t* output);
-bool StringToInt64(StringPiece16 input, int64_t* output);
+bool StringToInt64(std::string_view input, int64_t* output);
+bool StringToInt64(std::u16string_view input, int64_t* output);
-bool StringToUint64(StringPiece input, uint64_t* output);
-bool StringToUint64(StringPiece16 input, uint64_t* output);
+bool StringToUint64(std::string_view input, uint64_t* output);
+bool StringToUint64(std::u16string_view input, uint64_t* output);
-bool StringToSizeT(StringPiece input, size_t* output);
-bool StringToSizeT(StringPiece16 input, size_t* output);
+bool StringToSizeT(std::string_view input, size_t* output);
+bool StringToSizeT(std::u16string_view input, size_t* output);
// Hex encoding ----------------------------------------------------------------
@@ -102,30 +101,30 @@
// Best effort conversion, see StringToInt above for restrictions.
// Will only successful parse hex values that will fit into |output|, i.e.
// -0x80000000 < |input| < 0x7FFFFFFF.
-bool HexStringToInt(StringPiece input, int* output);
+bool HexStringToInt(std::string_view input, int* output);
// Best effort conversion, see StringToInt above for restrictions.
// Will only successful parse hex values that will fit into |output|, i.e.
// 0x00000000 < |input| < 0xFFFFFFFF.
// The string is not required to start with 0x.
-bool HexStringToUInt(StringPiece input, uint32_t* output);
+bool HexStringToUInt(std::string_view input, uint32_t* output);
// Best effort conversion, see StringToInt above for restrictions.
// Will only successful parse hex values that will fit into |output|, i.e.
// -0x8000000000000000 < |input| < 0x7FFFFFFFFFFFFFFF.
-bool HexStringToInt64(StringPiece input, int64_t* output);
+bool HexStringToInt64(std::string_view input, int64_t* output);
// Best effort conversion, see StringToInt above for restrictions.
// Will only successful parse hex values that will fit into |output|, i.e.
// 0x0000000000000000 < |input| < 0xFFFFFFFFFFFFFFFF.
// The string is not required to start with 0x.
-bool HexStringToUInt64(StringPiece input, uint64_t* output);
+bool HexStringToUInt64(std::string_view input, uint64_t* output);
// Similar to the previous functions, except that output is a vector of bytes.
// |*output| will contain as many bytes as were successfully parsed prior to the
// error. There is no overflow, but input.size() must be evenly divisible by 2.
// Leading 0x or +/- are not allowed.
-bool HexStringToBytes(StringPiece input, std::vector<uint8_t>* output);
+bool HexStringToBytes(std::string_view input, std::vector<uint8_t>* output);
} // namespace base
diff --git a/base/strings/string_piece.h b/base/strings/string_piece.h
deleted file mode 100644
index fa215ef..0000000
--- a/base/strings/string_piece.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-// Copied from strings/stringpiece.h with modifications
-//
-// A string-like object that points to a sized piece of memory.
-//
-// You can use StringPiece as a function or method parameter. A StringPiece
-// parameter can receive a double-quoted string literal argument, a "const
-// char*" argument, a string argument, or a StringPiece argument with no data
-// copying. Systematic use of StringPiece for arguments reduces data
-// copies and strlen() calls.
-//
-// Prefer passing StringPieces by value:
-// void MyFunction(StringPiece arg);
-// If circumstances require, you may also pass by const reference:
-// void MyFunction(const StringPiece& arg); // not preferred
-// Both of these have the same lifetime semantics. Passing by value
-// generates slightly smaller code. For more discussion, Googlers can see
-// the thread go/stringpiecebyvalue on c-users.
-
-#ifndef BASE_STRINGS_STRING_PIECE_H_
-#define BASE_STRINGS_STRING_PIECE_H_
-
-#include <string_view>
-
-namespace base {
-
-// Temporary definitions. These should be removed and code using the standard
-// ones.
-using StringPiece = std::string_view;
-using StringPiece16 = std::u16string_view;
-using WStringPiece = std::wstring_view;
-
-} // namespace base
-
-#endif // BASE_STRINGS_STRING_PIECE_H_
diff --git a/base/strings/string_split.cc b/base/strings/string_split.cc
index a57d537..f4c7eb2 100644
--- a/base/strings/string_split.cc
+++ b/base/strings/string_split.cc
@@ -18,11 +18,11 @@
template <typename char_type>
std::basic_string_view<char_type> WhitespaceForType();
template <>
-StringPiece16 WhitespaceForType<char16_t>() {
+std::u16string_view WhitespaceForType<char16_t>() {
return kWhitespaceUTF16;
}
template <>
-StringPiece WhitespaceForType<char>() {
+std::string_view WhitespaceForType<char>() {
return kWhitespaceASCII;
}
@@ -30,29 +30,34 @@
// 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
+// There is no corresponding FindFirstNotOf because std::string_view already
// implements these different versions that do the optimized searching.
-size_t FindFirstOf(StringPiece piece, char c, size_t pos) {
+size_t FindFirstOf(std::string_view piece, char c, size_t pos) {
return piece.find(c, pos);
}
-size_t FindFirstOf(StringPiece16 piece, char16 c, size_t pos) {
+size_t FindFirstOf(std::u16string_view piece, char16_t c, size_t pos) {
return piece.find(c, pos);
}
-size_t FindFirstOf(StringPiece piece, StringPiece one_of, size_t pos) {
+size_t FindFirstOf(std::string_view piece,
+ std::string_view one_of,
+ size_t pos) {
return piece.find_first_of(one_of, pos);
}
-size_t FindFirstOf(StringPiece16 piece, StringPiece16 one_of, size_t pos) {
+size_t FindFirstOf(std::u16string_view piece,
+ std::u16string_view 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
+// the corresponding string or std::string_view output, and can take single- or
// multiple-character delimiters.
//
// DelimiterType is either a character (Str::value_type) or a string piece of
-// multiple characters (std::basic_string_view<char>). 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.
+// multiple characters (std::basic_string_view<char>). std::string_view 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 char_type, typename OutputStringType, typename DelimiterType>
static std::vector<OutputStringType> SplitStringT(
std::basic_string_view<char_type> str,
@@ -87,7 +92,7 @@
return result;
}
-bool AppendStringKeyValue(StringPiece input,
+bool AppendStringKeyValue(std::string_view input,
char delimiter,
StringPairs* result) {
// Always append a new item regardless of success (it might be empty). The
@@ -103,9 +108,10 @@
result_pair.first.assign(input.substr(0, end_key_pos));
// Find the value string.
- StringPiece remains = input.substr(end_key_pos, input.size() - end_key_pos);
+ std::string_view remains =
+ input.substr(end_key_pos, input.size() - end_key_pos);
size_t begin_value_pos = remains.find_first_not_of(delimiter);
- if (begin_value_pos == StringPiece::npos) {
+ if (begin_value_pos == std::string_view::npos) {
return false; // No value.
}
result_pair.second.assign(
@@ -141,67 +147,68 @@
} // namespace
-std::vector<std::string> SplitString(StringPiece input,
- StringPiece separators,
+std::vector<std::string> SplitString(std::string_view input,
+ std::string_view separators,
WhitespaceHandling whitespace,
SplitResult result_type) {
if (separators.size() == 1) {
return SplitStringT<char, std::string, char>(input, separators[0],
whitespace, result_type);
}
- return SplitStringT<char, std::string, StringPiece>(input, separators,
- whitespace, result_type);
-}
-
-std::vector<string16> SplitString(StringPiece16 input,
- StringPiece16 separators,
- WhitespaceHandling whitespace,
- SplitResult result_type) {
- if (separators.size() == 1) {
- return SplitStringT<char16_t, string16, char16>(input, separators[0],
- whitespace, result_type);
- }
- return SplitStringT<char16_t, string16, StringPiece16>(
+ return SplitStringT<char, std::string, std::string_view>(
input, separators, whitespace, result_type);
}
-std::vector<StringPiece> SplitStringPiece(StringPiece input,
- StringPiece separators,
- WhitespaceHandling whitespace,
- SplitResult result_type) {
+std::vector<std::u16string> SplitString(std::u16string_view input,
+ std::u16string_view separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
if (separators.size() == 1) {
- return SplitStringT<char, StringPiece, char>(input, separators[0],
- whitespace, result_type);
- }
- return SplitStringT<char, StringPiece, 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<char16_t, StringPiece16, char16>(
+ return SplitStringT<char16_t, std::u16string, char16_t>(
input, separators[0], whitespace, result_type);
}
- return SplitStringT<char16_t, StringPiece16, StringPiece16>(
+ return SplitStringT<char16_t, std::u16string, std::u16string_view>(
input, separators, whitespace, result_type);
}
-bool SplitStringIntoKeyValuePairs(StringPiece input,
+std::vector<std::string_view> SplitStringPiece(std::string_view input,
+ std::string_view separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
+ if (separators.size() == 1) {
+ return SplitStringT<char, std::string_view, char>(input, separators[0],
+ whitespace, result_type);
+ }
+ return SplitStringT<char, std::string_view, std::string_view>(
+ input, separators, whitespace, result_type);
+}
+
+std::vector<std::u16string_view> SplitStringPiece(
+ std::u16string_view input,
+ std::u16string_view separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
+ if (separators.size() == 1) {
+ return SplitStringT<char16_t, std::u16string_view, char16_t>(
+ input, separators[0], whitespace, result_type);
+ }
+ return SplitStringT<char16_t, std::u16string_view, std::u16string_view>(
+ input, separators, whitespace, result_type);
+}
+
+bool SplitStringIntoKeyValuePairs(std::string_view input,
char key_value_delimiter,
char key_value_pair_delimiter,
StringPairs* key_value_pairs) {
key_value_pairs->clear();
- std::vector<StringPiece> pairs =
+ std::vector<std::string_view> pairs =
SplitStringPiece(input, std::string(1, key_value_pair_delimiter),
TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
key_value_pairs->reserve(pairs.size());
bool success = true;
- for (const StringPiece& pair : pairs) {
+ for (const std::string_view& pair : pairs) {
if (!AppendStringKeyValue(pair, key_value_delimiter, key_value_pairs)) {
// Don't return here, to allow for pairs without associated
// value or key; just record that the split failed.
@@ -211,17 +218,18 @@
return success;
}
-std::vector<string16> SplitStringUsingSubstr(StringPiece16 input,
- StringPiece16 delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type) {
- std::vector<string16> result;
+std::vector<std::u16string> SplitStringUsingSubstr(
+ std::u16string_view input,
+ std::u16string_view delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
+ std::vector<std::u16string> result;
SplitStringUsingSubstrT(input, delimiter, whitespace, result_type, &result);
return result;
}
-std::vector<std::string> SplitStringUsingSubstr(StringPiece input,
- StringPiece delimiter,
+std::vector<std::string> SplitStringUsingSubstr(std::string_view input,
+ std::string_view delimiter,
WhitespaceHandling whitespace,
SplitResult result_type) {
std::vector<std::string> result;
@@ -229,22 +237,22 @@
return result;
}
-std::vector<StringPiece16> SplitStringPieceUsingSubstr(
- StringPiece16 input,
- StringPiece16 delimiter,
+std::vector<std::u16string_view> SplitStringPieceUsingSubstr(
+ std::u16string_view input,
+ std::u16string_view delimiter,
WhitespaceHandling whitespace,
SplitResult result_type) {
- std::vector<StringPiece16> result;
+ std::vector<std::u16string_view> result;
SplitStringUsingSubstrT(input, delimiter, whitespace, result_type, &result);
return result;
}
-std::vector<StringPiece> SplitStringPieceUsingSubstr(
- StringPiece input,
- StringPiece delimiter,
+std::vector<std::string_view> SplitStringPieceUsingSubstr(
+ std::string_view input,
+ std::string_view delimiter,
WhitespaceHandling whitespace,
SplitResult result_type) {
- std::vector<StringPiece> result;
+ std::vector<std::string_view> result;
SplitStringUsingSubstrT(input, delimiter, whitespace, result_type, &result);
return result;
}
diff --git a/base/strings/string_split.h b/base/strings/string_split.h
index 6f8fc7c..7ba14e1 100644
--- a/base/strings/string_split.h
+++ b/base/strings/string_split.h
@@ -6,12 +6,10 @@
#define BASE_STRINGS_STRING_SPLIT_H_
#include <string>
+#include <string_view>
#include <utility>
#include <vector>
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-
namespace base {
enum WhitespaceHandling {
@@ -42,14 +40,14 @@
//
// std::vector<std::string> tokens = base::SplitString(
// input, ",;", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
-std::vector<std::string> SplitString(StringPiece input,
- StringPiece separators,
+std::vector<std::string> SplitString(std::string_view input,
+ std::string_view separators,
WhitespaceHandling whitespace,
SplitResult result_type);
-std::vector<string16> SplitString(StringPiece16 input,
- StringPiece16 separators,
- WhitespaceHandling whitespace,
- SplitResult result_type);
+std::vector<std::u16string> SplitString(std::u16string_view input,
+ std::u16string_view separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type);
// Like SplitString above except it returns a vector of StringPieces which
// reference the original buffer without copying. Although you have to be
@@ -63,14 +61,15 @@
// base::KEEP_WHITESPACE,
// base::SPLIT_WANT_NONEMPTY)) {
// ...
-std::vector<StringPiece> SplitStringPiece(StringPiece input,
- StringPiece separators,
- WhitespaceHandling whitespace,
- SplitResult result_type);
-std::vector<StringPiece16> SplitStringPiece(StringPiece16 input,
- StringPiece16 separators,
- WhitespaceHandling whitespace,
- SplitResult result_type);
+std::vector<std::string_view> SplitStringPiece(std::string_view input,
+ std::string_view separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type);
+std::vector<std::u16string_view> SplitStringPiece(
+ std::u16string_view input,
+ std::u16string_view separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type);
using StringPairs = std::vector<std::pair<std::string, std::string>>;
@@ -78,19 +77,20 @@
// removes whitespace leading each key and trailing each value. Returns true
// only if each pair has a non-empty key and value. |key_value_pairs| will
// include ("","") pairs for entries without |key_value_delimiter|.
-bool SplitStringIntoKeyValuePairs(StringPiece input,
+bool SplitStringIntoKeyValuePairs(std::string_view input,
char key_value_delimiter,
char key_value_pair_delimiter,
StringPairs* key_value_pairs);
// Similar to SplitString, but use a substring delimiter instead of a list of
// characters that are all possible delimiters.
-std::vector<string16> SplitStringUsingSubstr(StringPiece16 input,
- StringPiece16 delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type);
-std::vector<std::string> SplitStringUsingSubstr(StringPiece input,
- StringPiece delimiter,
+std::vector<std::u16string> SplitStringUsingSubstr(
+ std::u16string_view input,
+ std::u16string_view delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type);
+std::vector<std::string> SplitStringUsingSubstr(std::string_view input,
+ std::string_view delimiter,
WhitespaceHandling whitespace,
SplitResult result_type);
@@ -106,14 +106,14 @@
// base::KEEP_WHITESPACE,
// base::SPLIT_WANT_NONEMPTY)) {
// ...
-std::vector<StringPiece16> SplitStringPieceUsingSubstr(
- StringPiece16 input,
- StringPiece16 delimiter,
+std::vector<std::u16string_view> SplitStringPieceUsingSubstr(
+ std::u16string_view input,
+ std::u16string_view delimiter,
WhitespaceHandling whitespace,
SplitResult result_type);
-std::vector<StringPiece> SplitStringPieceUsingSubstr(
- StringPiece input,
- StringPiece delimiter,
+std::vector<std::string_view> SplitStringPieceUsingSubstr(
+ std::string_view input,
+ std::string_view delimiter,
WhitespaceHandling whitespace,
SplitResult result_type);
diff --git a/base/strings/string_tokenizer.h b/base/strings/string_tokenizer.h
index 50deb88..fe9401d 100644
--- a/base/strings/string_tokenizer.h
+++ b/base/strings/string_tokenizer.h
@@ -7,8 +7,7 @@
#include <algorithm>
#include <string>
-
-#include "base/strings/string_piece.h"
+#include <string_view>
namespace base {
diff --git a/base/strings/string_util.cc b/base/strings/string_util.cc
index f6ee491..d8f28d4 100644
--- a/base/strings/string_util.cc
+++ b/base/strings/string_util.cc
@@ -67,7 +67,7 @@
template <size_t size, typename CharacterType>
struct NonASCIIMask;
template <>
-struct NonASCIIMask<4, char16> {
+struct NonASCIIMask<4, char16_t> {
static inline uint32_t value() { return 0xFF80FF80U; }
};
template <>
@@ -75,7 +75,7 @@
static inline uint32_t value() { return 0x80808080U; }
};
template <>
-struct NonASCIIMask<8, char16> {
+struct NonASCIIMask<8, char16_t> {
static inline uint64_t value() { return 0xFF80FF80FF80FF80ULL; }
};
template <>
@@ -109,20 +109,20 @@
} // namespace
-std::string ToLowerASCII(StringPiece str) {
+std::string ToLowerASCII(std::string_view str) {
return ToLowerASCIIImpl<std::string>(str);
}
-string16 ToLowerASCII(StringPiece16 str) {
- return ToLowerASCIIImpl<string16>(str);
+std::u16string ToLowerASCII(std::u16string_view str) {
+ return ToLowerASCIIImpl<std::u16string>(str);
}
-std::string ToUpperASCII(StringPiece str) {
+std::string ToUpperASCII(std::string_view str) {
return ToUpperASCIIImpl<std::string>(str);
}
-string16 ToUpperASCII(StringPiece16 str) {
- return ToUpperASCIIImpl<string16>(str);
+std::u16string ToUpperASCII(std::u16string_view str) {
+ return ToUpperASCIIImpl<std::u16string>(str);
}
template <class StringType>
@@ -153,24 +153,24 @@
return 1;
}
-int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b) {
+int CompareCaseInsensitiveASCII(std::string_view a, std::string_view b) {
return CompareCaseInsensitiveASCIIT<std::string>(a, b);
}
-int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
- return CompareCaseInsensitiveASCIIT<string16>(a, b);
+int CompareCaseInsensitiveASCII(std::u16string_view a, std::u16string_view b) {
+ return CompareCaseInsensitiveASCIIT<std::u16string>(a, b);
}
-bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b) {
+bool EqualsCaseInsensitiveASCII(std::string_view a, std::string_view b) {
if (a.length() != b.length())
return false;
return CompareCaseInsensitiveASCIIT<std::string>(a, b) == 0;
}
-bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
+bool EqualsCaseInsensitiveASCII(std::u16string_view a, std::u16string_view b) {
if (a.length() != b.length())
return false;
- return CompareCaseInsensitiveASCIIT<string16>(a, b) == 0;
+ return CompareCaseInsensitiveASCIIT<std::u16string>(a, b) == 0;
}
template <class StringType>
@@ -180,31 +180,32 @@
std::basic_string_view<typename StringType::value_type> replace_with,
StringType* output);
-bool ReplaceChars(const string16& input,
- StringPiece16 replace_chars,
- const string16& replace_with,
- string16* output) {
- return ReplaceCharsT(input, replace_chars, StringPiece16(replace_with),
+bool ReplaceChars(const std::u16string& input,
+ std::u16string_view replace_chars,
+ const std::u16string& replace_with,
+ std::u16string* output) {
+ return ReplaceCharsT(input, replace_chars, std::u16string_view(replace_with),
output);
}
bool ReplaceChars(const std::string& input,
- StringPiece replace_chars,
+ std::string_view replace_chars,
const std::string& replace_with,
std::string* output) {
- return ReplaceCharsT(input, replace_chars, StringPiece(replace_with), output);
+ return ReplaceCharsT(input, replace_chars, std::string_view(replace_with),
+ output);
}
-bool RemoveChars(const string16& input,
- StringPiece16 remove_chars,
- string16* output) {
- return ReplaceCharsT(input, remove_chars, StringPiece16(), output);
+bool RemoveChars(const std::u16string& input,
+ std::u16string_view remove_chars,
+ std::u16string* output) {
+ return ReplaceCharsT(input, remove_chars, std::u16string_view(), output);
}
bool RemoveChars(const std::string& input,
- StringPiece remove_chars,
+ std::string_view remove_chars,
std::string* output) {
- return ReplaceCharsT(input, remove_chars, StringPiece(), output);
+ return ReplaceCharsT(input, remove_chars, std::string_view(), output);
}
template <typename Str>
@@ -214,8 +215,8 @@
TrimPositions positions,
Str* output) {
// Find the edges of leading/trailing whitespace as desired. Need to use
- // a StringPiece version of input to be able to call find* on it with the
- // StringPiece version of trim_chars (normally the trim_chars will be a
+ // a std::string_view version of input to be able to call find* on it with the
+ // std::string_view version of trim_chars (normally the trim_chars will be a
// constant so avoid making a copy).
std::basic_string_view<typename Str::value_type> input_piece(input);
const size_t last_char = input.length() - 1;
@@ -245,14 +246,14 @@
((last_good_char == last_char) ? TRIM_NONE : TRIM_TRAILING));
}
-bool TrimString(const string16& input,
- StringPiece16 trim_chars,
- string16* output) {
+bool TrimString(const std::u16string& input,
+ std::u16string_view trim_chars,
+ std::u16string* output) {
return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
}
bool TrimString(const std::string& input,
- StringPiece trim_chars,
+ std::string_view trim_chars,
std::string* output) {
return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
}
@@ -273,15 +274,15 @@
return input.substr(begin, end - begin);
}
-StringPiece16 TrimString(StringPiece16 input,
- StringPiece16 trim_chars,
- TrimPositions positions) {
+std::u16string_view TrimString(std::u16string_view input,
+ std::u16string_view trim_chars,
+ TrimPositions positions) {
return TrimStringPieceT(input, trim_chars, positions);
}
-StringPiece TrimString(StringPiece input,
- StringPiece trim_chars,
- TrimPositions positions) {
+std::string_view TrimString(std::string_view input,
+ std::string_view trim_chars,
+ TrimPositions positions) {
return TrimStringPieceT(input, trim_chars, positions);
}
@@ -321,24 +322,29 @@
output->clear();
}
-TrimPositions TrimWhitespace(const string16& input,
+TrimPositions TrimWhitespace(const std::u16string& input,
TrimPositions positions,
- string16* output) {
- return TrimStringT(input, StringPiece16(kWhitespaceUTF16), positions, output);
+ std::u16string* output) {
+ return TrimStringT(input, std::u16string_view(kWhitespaceUTF16), positions,
+ output);
}
-StringPiece16 TrimWhitespace(StringPiece16 input, TrimPositions positions) {
- return TrimStringPieceT(input, StringPiece16(kWhitespaceUTF16), positions);
+std::u16string_view TrimWhitespace(std::u16string_view input,
+ TrimPositions positions) {
+ return TrimStringPieceT(input, std::u16string_view(kWhitespaceUTF16),
+ positions);
}
TrimPositions TrimWhitespaceASCII(const std::string& input,
TrimPositions positions,
std::string* output) {
- return TrimStringT(input, StringPiece(kWhitespaceASCII), positions, output);
+ return TrimStringT(input, std::string_view(kWhitespaceASCII), positions,
+ output);
}
-StringPiece TrimWhitespaceASCII(StringPiece input, TrimPositions positions) {
- return TrimStringPieceT(input, StringPiece(kWhitespaceASCII), positions);
+std::string_view TrimWhitespaceASCII(std::string_view input,
+ TrimPositions positions) {
+ return TrimStringPieceT(input, std::string_view(kWhitespaceASCII), positions);
}
template <typename STR>
@@ -382,8 +388,8 @@
return result;
}
-string16 CollapseWhitespace(const string16& text,
- bool trim_sequences_with_line_breaks) {
+std::u16string CollapseWhitespace(const std::u16string& text,
+ bool trim_sequences_with_line_breaks) {
return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
}
@@ -392,12 +398,13 @@
return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
}
-bool ContainsOnlyChars(StringPiece input, StringPiece characters) {
- return input.find_first_not_of(characters) == StringPiece::npos;
+bool ContainsOnlyChars(std::string_view input, std::string_view characters) {
+ return input.find_first_not_of(characters) == std::string_view::npos;
}
-bool ContainsOnlyChars(StringPiece16 input, StringPiece16 characters) {
- return input.find_first_not_of(characters) == StringPiece16::npos;
+bool ContainsOnlyChars(std::u16string_view input,
+ std::u16string_view characters) {
+ return input.find_first_not_of(characters) == std::u16string_view::npos;
}
template <class Char>
@@ -430,15 +437,15 @@
return !(all_char_bits & non_ascii_bit_mask);
}
-bool IsStringASCII(StringPiece str) {
+bool IsStringASCII(std::string_view str) {
return DoIsStringASCII(str.data(), str.length());
}
-bool IsStringASCII(StringPiece16 str) {
+bool IsStringASCII(std::u16string_view str) {
return DoIsStringASCII(str.data(), str.length());
}
-bool IsStringUTF8(StringPiece str) {
+bool IsStringUTF8(std::string_view str) {
const char* src = str.data();
int32_t src_len = static_cast<int32_t>(str.length());
int32_t char_index = 0;
@@ -453,8 +460,8 @@
}
// 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
+// constant for the lowercase_ascii parameter. Constructing a std::string_view
+// from a C constant requires running strlen, so the result will be two passes
// through the buffers, one to file the length of lowercase_ascii, and one to
// compare each letter.
//
@@ -466,11 +473,11 @@
//
// The hardcoded strings are typically very short so it doesn't matter, and the
// string piece gives additional flexibility for the caller (doesn't have to be
-// null terminated) so we choose the StringPiece route.
+// null terminated) so we choose the std::string_view route.
template <typename Str>
static inline bool DoLowerCaseEqualsASCII(
std::basic_string_view<typename Str::value_type> str,
- StringPiece lowercase_ascii) {
+ std::string_view lowercase_ascii) {
if (str.size() != lowercase_ascii.size())
return false;
for (size_t i = 0; i < str.size(); i++) {
@@ -480,15 +487,17 @@
return true;
}
-bool LowerCaseEqualsASCII(StringPiece str, StringPiece lowercase_ascii) {
+bool LowerCaseEqualsASCII(std::string_view str,
+ std::string_view lowercase_ascii) {
return DoLowerCaseEqualsASCII<std::string>(str, lowercase_ascii);
}
-bool LowerCaseEqualsASCII(StringPiece16 str, StringPiece lowercase_ascii) {
- return DoLowerCaseEqualsASCII<string16>(str, lowercase_ascii);
+bool LowerCaseEqualsASCII(std::u16string_view str,
+ std::string_view lowercase_ascii) {
+ return DoLowerCaseEqualsASCII<std::u16string>(str, lowercase_ascii);
}
-bool EqualsASCII(StringPiece16 str, StringPiece ascii) {
+bool EqualsASCII(std::u16string_view str, std::string_view ascii) {
if (str.length() != ascii.length())
return false;
return std::equal(ascii.begin(), ascii.end(), str.begin());
@@ -517,14 +526,14 @@
}
}
-bool StartsWith(StringPiece str,
- StringPiece search_for,
+bool StartsWith(std::string_view str,
+ std::string_view search_for,
CompareCase case_sensitivity) {
return StartsWithT(str, search_for, case_sensitivity);
}
-bool StartsWith(StringPiece16 str,
- StringPiece16 search_for,
+bool StartsWith(std::u16string_view str,
+ std::u16string_view search_for,
CompareCase case_sensitivity) {
return StartsWithT(str, search_for, case_sensitivity);
}
@@ -554,16 +563,16 @@
}
}
-bool EndsWith(StringPiece str,
- StringPiece search_for,
+bool EndsWith(std::string_view str,
+ std::string_view search_for,
CompareCase case_sensitivity) {
return EndsWithT<std::string>(str, search_for, case_sensitivity);
}
-bool EndsWith(StringPiece16 str,
- StringPiece16 search_for,
+bool EndsWith(std::u16string_view str,
+ std::u16string_view search_for,
CompareCase case_sensitivity) {
- return EndsWithT<string16>(str, search_for, case_sensitivity);
+ return EndsWithT<std::u16string>(str, search_for, case_sensitivity);
}
char HexDigitToInt(char16_t c) {
@@ -589,7 +598,7 @@
static const char* const kByteStringsUnlocalized[] = {" B", " kB", " MB",
" GB", " TB", " PB"};
-string16 FormatBytesUnlocalized(int64_t bytes) {
+std::u16string FormatBytesUnlocalized(int64_t bytes) {
double unit_amount = static_cast<double>(bytes);
size_t dimension = 0;
const int kKilo = 1024;
@@ -800,37 +809,37 @@
ReplaceType::REPLACE_ALL);
}
-void ReplaceFirstSubstringAfterOffset(string16* str,
+void ReplaceFirstSubstringAfterOffset(std::u16string* str,
size_t start_offset,
- StringPiece16 find_this,
- StringPiece16 replace_with) {
+ std::u16string_view find_this,
+ std::u16string_view replace_with) {
DoReplaceMatchesAfterOffset(str, start_offset,
- SubstringMatcher<string16>{find_this},
+ SubstringMatcher<std::u16string>{find_this},
replace_with, ReplaceType::REPLACE_FIRST);
}
void ReplaceFirstSubstringAfterOffset(std::string* str,
size_t start_offset,
- StringPiece find_this,
- StringPiece replace_with) {
+ std::string_view find_this,
+ std::string_view replace_with) {
DoReplaceMatchesAfterOffset(str, start_offset,
SubstringMatcher<std::string>{find_this},
replace_with, ReplaceType::REPLACE_FIRST);
}
-void ReplaceSubstringsAfterOffset(string16* str,
+void ReplaceSubstringsAfterOffset(std::u16string* str,
size_t start_offset,
- StringPiece16 find_this,
- StringPiece16 replace_with) {
+ std::u16string_view find_this,
+ std::u16string_view replace_with) {
DoReplaceMatchesAfterOffset(str, start_offset,
- SubstringMatcher<string16>{find_this},
+ SubstringMatcher<std::u16string>{find_this},
replace_with, ReplaceType::REPLACE_ALL);
}
void ReplaceSubstringsAfterOffset(std::string* str,
size_t start_offset,
- StringPiece find_this,
- StringPiece replace_with) {
+ std::string_view find_this,
+ std::string_view replace_with) {
DoReplaceMatchesAfterOffset(str, start_offset,
SubstringMatcher<std::string>{find_this},
replace_with, ReplaceType::REPLACE_ALL);
@@ -849,7 +858,7 @@
return WriteIntoT(str, length_with_null);
}
-char16* WriteInto(string16* str, size_t length_with_null) {
+char16_t* WriteInto(std::u16string* str, size_t length_with_null) {
return WriteIntoT(str, length_with_null);
}
@@ -892,12 +901,12 @@
}
std::string JoinString(const std::vector<std::string>& parts,
- StringPiece separator) {
+ std::string_view separator) {
return JoinStringT(parts, separator);
}
-string16 JoinString(const std::vector<string16>& parts,
- StringPiece16 separator) {
+std::u16string JoinString(const std::vector<std::u16string>& parts,
+ std::u16string_view separator) {
return JoinStringT(parts, separator);
}
@@ -906,23 +915,23 @@
#pragma optimize("", on)
#endif
-std::string JoinString(const std::vector<StringPiece>& parts,
- StringPiece separator) {
+std::string JoinString(const std::vector<std::string_view>& parts,
+ std::string_view separator) {
return JoinStringT(parts, separator);
}
-string16 JoinString(const std::vector<StringPiece16>& parts,
- StringPiece16 separator) {
+std::u16string JoinString(const std::vector<std::u16string_view>& parts,
+ std::u16string_view separator) {
return JoinStringT(parts, separator);
}
-std::string JoinString(std::initializer_list<StringPiece> parts,
- StringPiece separator) {
+std::string JoinString(std::initializer_list<std::string_view> parts,
+ std::string_view separator) {
return JoinStringT(parts, separator);
}
-string16 JoinString(std::initializer_list<StringPiece16> parts,
- StringPiece16 separator) {
+std::u16string JoinString(std::initializer_list<std::u16string_view> parts,
+ std::u16string_view separator) {
return JoinStringT(parts, separator);
}
@@ -981,25 +990,27 @@
return formatted;
}
-string16 ReplaceStringPlaceholders(const string16& format_string,
- const std::vector<string16>& subst,
- std::vector<size_t>* offsets) {
+std::u16string ReplaceStringPlaceholders(
+ const std::u16string& format_string,
+ const std::vector<std::u16string>& subst,
+ std::vector<size_t>* offsets) {
return DoReplaceStringPlaceholders(format_string, subst, offsets);
}
-std::string ReplaceStringPlaceholders(StringPiece format_string,
+std::string ReplaceStringPlaceholders(std::string_view format_string,
const std::vector<std::string>& subst,
std::vector<size_t>* offsets) {
return DoReplaceStringPlaceholders(format_string, subst, offsets);
}
-string16 ReplaceStringPlaceholders(const string16& format_string,
- const string16& a,
- size_t* offset) {
+std::u16string ReplaceStringPlaceholders(const std::u16string& format_string,
+ const std::u16string& a,
+ size_t* offset) {
std::vector<size_t> offsets;
- std::vector<string16> subst;
+ std::vector<std::u16string> subst;
subst.push_back(a);
- string16 result = ReplaceStringPlaceholders(format_string, subst, &offsets);
+ std::u16string result =
+ ReplaceStringPlaceholders(format_string, subst, &offsets);
DCHECK_EQ(1U, offsets.size());
if (offset)
diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index 9b3c608..9ed66b2 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -14,11 +14,10 @@
#include <initializer_list>
#include <string>
+#include <string_view>
#include <vector>
#include "base/compiler_specific.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h" // For implicit conversions.
#include "util/build_config.h"
namespace base {
@@ -58,7 +57,7 @@
inline char ToLowerASCII(char c) {
return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
}
-inline char16 ToLowerASCII(char16 c) {
+inline char16_t ToLowerASCII(char16_t c) {
return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
}
@@ -67,17 +66,17 @@
inline char ToUpperASCII(char c) {
return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
}
-inline char16 ToUpperASCII(char16 c) {
+inline char16_t ToUpperASCII(char16_t c) {
return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
}
// Converts the given string to it's ASCII-lowercase equivalent.
-std::string ToLowerASCII(StringPiece str);
-string16 ToLowerASCII(StringPiece16 str);
+std::string ToLowerASCII(std::string_view str);
+std::u16string ToLowerASCII(std::u16string_view str);
// Converts the given string to it's ASCII-uppercase equivalent.
-std::string ToUpperASCII(StringPiece str);
-string16 ToUpperASCII(StringPiece16 str);
+std::string ToUpperASCII(std::string_view str);
+std::u16string ToUpperASCII(std::u16string_view str);
// Functor for case-insensitive ASCII comparisons for STL algorithms like
// std::search.
@@ -102,21 +101,21 @@
// (unlike strcasecmp which can return values greater or less than 1/-1). For
// full Unicode support, use base::i18n::ToLower or base::i18h::FoldCase
// and then just call the normal string operators on the result.
-int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b);
-int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
+int CompareCaseInsensitiveASCII(std::string_view a, std::string_view b);
+int CompareCaseInsensitiveASCII(std::u16string_view a, std::u16string_view b);
// Equality for ASCII case-insensitive comparisons. For full Unicode support,
// use base::i18n::ToLower or base::i18h::FoldCase and then compare with either
// == or !=.
-bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b);
-bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
+bool EqualsCaseInsensitiveASCII(std::string_view a, std::string_view b);
+bool EqualsCaseInsensitiveASCII(std::u16string_view a, std::u16string_view b);
// Contains the set of characters representing whitespace in the corresponding
// encoding. Null-terminated. The ASCII versions are the whitespaces as defined
// by HTML5, and don't include control characters.
-extern const char16 kWhitespaceUTF16[]; // Includes Unicode.
+extern const char16_t kWhitespaceUTF16[]; // Includes Unicode.
extern const char kWhitespaceASCII[];
-extern const char16 kWhitespaceASCIIAs16[]; // No unicode.
+extern const char16_t kWhitespaceASCIIAs16[]; // No unicode.
// Null-terminated string representing the UTF-8 byte order mark.
extern const char kUtf8ByteOrderMark[];
@@ -124,11 +123,11 @@
// Removes characters in |remove_chars| from anywhere in |input|. Returns true
// if any characters were removed. |remove_chars| must be null-terminated.
// NOTE: Safe to use the same variable for both |input| and |output|.
-bool RemoveChars(const string16& input,
- StringPiece16 remove_chars,
- string16* output);
+bool RemoveChars(const std::u16string& input,
+ std::u16string_view remove_chars,
+ std::u16string* output);
bool RemoveChars(const std::string& input,
- StringPiece remove_chars,
+ std::string_view remove_chars,
std::string* output);
// Replaces characters in |replace_chars| from anywhere in |input| with
@@ -136,12 +135,12 @@
// the |replace_with| string. Returns true if any characters were replaced.
// |replace_chars| must be null-terminated.
// NOTE: Safe to use the same variable for both |input| and |output|.
-bool ReplaceChars(const string16& input,
- StringPiece16 replace_chars,
- const string16& replace_with,
- string16* output);
+bool ReplaceChars(const std::u16string& input,
+ std::u16string_view replace_chars,
+ const std::u16string& replace_with,
+ std::u16string* output);
bool ReplaceChars(const std::string& input,
- StringPiece replace_chars,
+ std::string_view replace_chars,
const std::string& replace_with,
std::string* output);
@@ -158,21 +157,21 @@
//
// It is safe to use the same variable for both |input| and |output| (this is
// the normal usage to trim in-place).
-bool TrimString(const string16& input,
- StringPiece16 trim_chars,
- string16* output);
+bool TrimString(const std::u16string& input,
+ std::u16string_view trim_chars,
+ std::u16string* output);
bool TrimString(const std::string& input,
- StringPiece trim_chars,
+ std::string_view trim_chars,
std::string* output);
-// StringPiece versions of the above. The returned pieces refer to the original
-// buffer.
-StringPiece16 TrimString(StringPiece16 input,
- StringPiece16 trim_chars,
- TrimPositions positions);
-StringPiece TrimString(StringPiece input,
- StringPiece trim_chars,
- TrimPositions positions);
+// std::string_view versions of the above. The returned pieces refer to the
+// original buffer.
+std::u16string_view TrimString(std::u16string_view input,
+ std::u16string_view trim_chars,
+ TrimPositions positions);
+std::string_view TrimString(std::string_view input,
+ std::string_view trim_chars,
+ TrimPositions positions);
// Truncates a string to the nearest UTF-8 character that will leave
// the string less than or equal to the specified byte size.
@@ -182,19 +181,21 @@
// Trims any whitespace from either end of the input string.
//
-// The StringPiece versions return a substring referencing the input buffer.
-// The ASCII versions look only for ASCII whitespace.
+// The std::string_view versions return a substring referencing the input
+// buffer. The ASCII versions look only for ASCII whitespace.
//
// The std::string versions return where whitespace was found.
// NOTE: Safe to use the same variable for both input and output.
-TrimPositions TrimWhitespace(const string16& input,
+TrimPositions TrimWhitespace(const std::u16string& input,
TrimPositions positions,
- string16* output);
-StringPiece16 TrimWhitespace(StringPiece16 input, TrimPositions positions);
+ std::u16string* output);
+std::u16string_view TrimWhitespace(std::u16string_view input,
+ TrimPositions positions);
TrimPositions TrimWhitespaceASCII(const std::string& input,
TrimPositions positions,
std::string* output);
-StringPiece TrimWhitespaceASCII(StringPiece input, TrimPositions positions);
+std::string_view TrimWhitespaceASCII(std::string_view input,
+ TrimPositions positions);
// Searches for CR or LF characters. Removes all contiguous whitespace
// strings that contain them. This is useful when trying to deal with text
@@ -204,15 +205,16 @@
// (2) If |trim_sequences_with_line_breaks| is true, any other whitespace
// sequences containing a CR or LF are trimmed.
// (3) All other whitespace sequences are converted to single spaces.
-string16 CollapseWhitespace(const string16& text,
- bool trim_sequences_with_line_breaks);
+std::u16string CollapseWhitespace(const std::u16string& text,
+ bool trim_sequences_with_line_breaks);
std::string CollapseWhitespaceASCII(const std::string& text,
bool trim_sequences_with_line_breaks);
// Returns true if |input| is empty or contains only characters found in
// |characters|.
-bool ContainsOnlyChars(StringPiece input, StringPiece characters);
-bool ContainsOnlyChars(StringPiece16 input, StringPiece16 characters);
+bool ContainsOnlyChars(std::string_view input, std::string_view characters);
+bool ContainsOnlyChars(std::u16string_view input,
+ std::u16string_view 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
@@ -228,19 +230,21 @@
//
// IsStringASCII assumes the input is likely all ASCII, and does not leave early
// if it is not the case.
-bool IsStringUTF8(StringPiece str);
-bool IsStringASCII(StringPiece str);
-bool IsStringASCII(StringPiece16 str);
+bool IsStringUTF8(std::string_view str);
+bool IsStringASCII(std::string_view str);
+bool IsStringASCII(std::u16string_view str);
// Compare the lower-case form of the given string against the given
// previously-lower-cased ASCII string (typically a constant).
-bool LowerCaseEqualsASCII(StringPiece str, StringPiece lowecase_ascii);
-bool LowerCaseEqualsASCII(StringPiece16 str, StringPiece lowecase_ascii);
+bool LowerCaseEqualsASCII(std::string_view str,
+ std::string_view lowecase_ascii);
+bool LowerCaseEqualsASCII(std::u16string_view str,
+ std::string_view lowecase_ascii);
// Performs a case-sensitive string compare of the given 16-bit string against
// the given 8-bit ASCII string (typically a constant). The behavior is
// undefined if the |ascii| string is not ASCII.
-bool EqualsASCII(StringPiece16 str, StringPiece ascii);
+bool EqualsASCII(std::u16string_view str, std::string_view ascii);
// Indicates case sensitivity of comparisons. Only ASCII case insensitivity
// is supported. Full Unicode case-insensitive conversions would need to go in
@@ -255,17 +259,17 @@
INSENSITIVE_ASCII,
};
-bool StartsWith(StringPiece str,
- StringPiece search_for,
+bool StartsWith(std::string_view str,
+ std::string_view search_for,
CompareCase case_sensitivity);
-bool StartsWith(StringPiece16 str,
- StringPiece16 search_for,
+bool StartsWith(std::u16string_view str,
+ std::u16string_view search_for,
CompareCase case_sensitivity);
-bool EndsWith(StringPiece str,
- StringPiece search_for,
+bool EndsWith(std::string_view str,
+ std::string_view search_for,
CompareCase case_sensitivity);
-bool EndsWith(StringPiece16 str,
- StringPiece16 search_for,
+bool EndsWith(std::u16string_view str,
+ std::u16string_view search_for,
CompareCase case_sensitivity);
// Determines the type of ASCII character, independent of locale (the C
@@ -311,18 +315,18 @@
// appropriate for use in any UI; use of FormatBytes and friends in ui/base is
// highly recommended instead. TODO(avi): Figure out how to get callers to use
// FormatBytes instead; remove this.
-string16 FormatBytesUnlocalized(int64_t bytes);
+std::u16string FormatBytesUnlocalized(int64_t bytes);
// Starting at |start_offset| (usually 0), replace the first instance of
// |find_this| with |replace_with|.
-void ReplaceFirstSubstringAfterOffset(base::string16* str,
+void ReplaceFirstSubstringAfterOffset(std::u16string* str,
size_t start_offset,
- StringPiece16 find_this,
- StringPiece16 replace_with);
+ std::u16string_view find_this,
+ std::u16string_view replace_with);
void ReplaceFirstSubstringAfterOffset(std::string* str,
size_t start_offset,
- StringPiece find_this,
- StringPiece replace_with);
+ std::string_view find_this,
+ std::string_view replace_with);
// Starting at |start_offset| (usually 0), look through |str| and replace all
// instances of |find_this| with |replace_with|.
@@ -330,14 +334,14 @@
// This does entire substrings; use std::replace in <algorithm> for single
// characters, for example:
// std::replace(str.begin(), str.end(), 'a', 'b');
-void ReplaceSubstringsAfterOffset(string16* str,
+void ReplaceSubstringsAfterOffset(std::u16string* str,
size_t start_offset,
- StringPiece16 find_this,
- StringPiece16 replace_with);
+ std::u16string_view find_this,
+ std::u16string_view replace_with);
void ReplaceSubstringsAfterOffset(std::string* str,
size_t start_offset,
- StringPiece find_this,
- StringPiece replace_with);
+ std::string_view find_this,
+ std::string_view replace_with);
// Reserves enough memory in |str| to accommodate |length_with_null| characters,
// sets the size of |str| to |length_with_null - 1| characters, and returns a
@@ -360,51 +364,52 @@
// than str.c_str() will get back a string of whatever size |str| had on entry
// to this function (probably 0).
char* WriteInto(std::string* str, size_t length_with_null);
-char16* WriteInto(string16* str, size_t length_with_null);
+char16_t* WriteInto(std::u16string* 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.
//
-// If possible, callers should build a vector of StringPieces and use the
-// StringPiece variant, so that they do not create unnecessary copies of
+// If possible, callers should build a vector of std::string_views and use the
+// std::string_view variant, so that they do not create unnecessary copies of
// strings. For example, instead of using SplitString, modifying the vector,
// then using JoinString, use SplitStringPiece followed by JoinString so that no
// copies of those strings are created until the final join operation.
//
// Use StrCat (in base/strings/strcat.h) if you don't need a separator.
std::string JoinString(const std::vector<std::string>& parts,
- StringPiece separator);
-string16 JoinString(const std::vector<string16>& parts,
- StringPiece16 separator);
-std::string JoinString(const std::vector<StringPiece>& parts,
- StringPiece separator);
-string16 JoinString(const std::vector<StringPiece16>& parts,
- StringPiece16 separator);
+ std::string_view separator);
+std::u16string JoinString(const std::vector<std::u16string>& parts,
+ std::u16string_view separator);
+std::string JoinString(const std::vector<std::string_view>& parts,
+ std::string_view separator);
+std::u16string JoinString(const std::vector<std::u16string_view>& parts,
+ std::u16string_view separator);
// Explicit initializer_list overloads are required to break ambiguity when used
// with a literal initializer list (otherwise the compiler would not be able to
-// decide between the string and StringPiece overloads).
-std::string JoinString(std::initializer_list<StringPiece> parts,
- StringPiece separator);
-string16 JoinString(std::initializer_list<StringPiece16> parts,
- StringPiece16 separator);
+// decide between the string and std::string_view overloads).
+std::string JoinString(std::initializer_list<std::string_view> parts,
+ std::string_view separator);
+std::u16string JoinString(std::initializer_list<std::u16string_view> parts,
+ std::u16string_view separator);
// Replace $1-$2-$3..$9 in the format string with values from |subst|.
// Additionally, any number of consecutive '$' characters is replaced by that
// number less one. Eg $$->$, $$$->$$, etc. The offsets parameter here can be
// NULL. This only allows you to use up to nine replacements.
-string16 ReplaceStringPlaceholders(const string16& format_string,
- const std::vector<string16>& subst,
- std::vector<size_t>* offsets);
+std::u16string ReplaceStringPlaceholders(
+ const std::u16string& format_string,
+ const std::vector<std::u16string>& subst,
+ std::vector<size_t>* offsets);
-std::string ReplaceStringPlaceholders(StringPiece format_string,
+std::string ReplaceStringPlaceholders(std::string_view format_string,
const std::vector<std::string>& subst,
std::vector<size_t>* offsets);
// Single-string shortcut for ReplaceStringHolders. |offset| may be NULL.
-string16 ReplaceStringPlaceholders(const string16& format_string,
- const string16& a,
- size_t* offset);
+std::u16string ReplaceStringPlaceholders(const std::u16string& format_string,
+ const std::u16string& a,
+ size_t* offset);
} // namespace base
diff --git a/base/strings/string_util_constants.cc b/base/strings/string_util_constants.cc
index ed17fcd..de88454 100644
--- a/base/strings/string_util_constants.cc
+++ b/base/strings/string_util_constants.cc
@@ -34,7 +34,7 @@
0x3000, /* IDEOGRAPHIC SPACE */ \
0
-const char16 kWhitespaceUTF16[] = {WHITESPACE_UNICODE};
+const char16_t kWhitespaceUTF16[] = {WHITESPACE_UNICODE};
const char kWhitespaceASCII[] = {0x09, // CHARACTER TABULATION
0x0A, // LINE FEED (LF)
@@ -44,13 +44,13 @@
0x20, // SPACE
0};
-const char16 kWhitespaceASCIIAs16[] = {0x09, // CHARACTER TABULATION
- 0x0A, // LINE FEED (LF)
- 0x0B, // LINE TABULATION
- 0x0C, // FORM FEED (FF)
- 0x0D, // CARRIAGE RETURN (CR)
- 0x20, // SPACE
- 0};
+const char16_t kWhitespaceASCIIAs16[] = {0x09, // CHARACTER TABULATION
+ 0x0A, // LINE FEED (LF)
+ 0x0B, // LINE TABULATION
+ 0x0C, // FORM FEED (FF)
+ 0x0D, // CARRIAGE RETURN (CR)
+ 0x20, // SPACE
+ 0};
const char kUtf8ByteOrderMark[] = "\xEF\xBB\xBF";
diff --git a/base/strings/utf_offset_string_conversions.cc b/base/strings/utf_offset_string_conversions.cc
index 177839a..ee55a24 100644
--- a/base/strings/utf_offset_string_conversions.cc
+++ b/base/strings/utf_offset_string_conversions.cc
@@ -8,9 +8,9 @@
#include <algorithm>
#include <memory>
+#include <string_view>
#include "base/logging.h"
-#include "base/strings/string_piece.h"
#include "base/strings/utf_string_conversion_utils.h"
namespace base {
@@ -37,7 +37,7 @@
size_t* offset,
size_t limit) {
DCHECK(offset);
- if (*offset == string16::npos)
+ if (*offset == std::u16string::npos)
return;
int adjustment = 0;
for (Adjustments::const_iterator i = adjustments.begin();
@@ -45,7 +45,7 @@
if (*offset <= i->original_offset)
break;
if (*offset < (i->original_offset + i->original_length)) {
- *offset = string16::npos;
+ *offset = std::u16string::npos;
return;
}
adjustment += static_cast<int>(i->original_length - i->output_length);
@@ -53,7 +53,7 @@
*offset -= adjustment;
if (*offset > limit)
- *offset = string16::npos;
+ *offset = std::u16string::npos;
}
// static
@@ -70,7 +70,7 @@
// static
void OffsetAdjuster::UnadjustOffset(const Adjustments& adjustments,
size_t* offset) {
- if (*offset == string16::npos)
+ if (*offset == std::u16string::npos)
return;
int adjustment = 0;
for (Adjustments::const_iterator i = adjustments.begin();
@@ -79,7 +79,7 @@
break;
adjustment += static_cast<int>(i->original_length - i->output_length);
if ((*offset + adjustment) < (i->original_offset + i->original_length)) {
- *offset = string16::npos;
+ *offset = std::u16string::npos;
return;
}
}
@@ -221,39 +221,39 @@
bool UTF8ToUTF16WithAdjustments(
const char* src,
size_t src_len,
- string16* output,
+ std::u16string* output,
base::OffsetAdjuster::Adjustments* adjustments) {
PrepareForUTF16Or32Output(src, src_len, output);
return ConvertUnicode(src, src_len, output, adjustments);
}
-string16 UTF8ToUTF16WithAdjustments(
- const base::StringPiece& utf8,
+std::u16string UTF8ToUTF16WithAdjustments(
+ const std::string_view& utf8,
base::OffsetAdjuster::Adjustments* adjustments) {
- string16 result;
+ std::u16string result;
UTF8ToUTF16WithAdjustments(utf8.data(), utf8.length(), &result, adjustments);
return result;
}
-string16 UTF8ToUTF16AndAdjustOffsets(
- const base::StringPiece& utf8,
+std::u16string UTF8ToUTF16AndAdjustOffsets(
+ const std::string_view& utf8,
std::vector<size_t>* offsets_for_adjustment) {
for (size_t& offset : *offsets_for_adjustment) {
if (offset > utf8.length())
- offset = string16::npos;
+ offset = std::u16string::npos;
}
OffsetAdjuster::Adjustments adjustments;
- string16 result = UTF8ToUTF16WithAdjustments(utf8, &adjustments);
+ std::u16string result = UTF8ToUTF16WithAdjustments(utf8, &adjustments);
OffsetAdjuster::AdjustOffsets(adjustments, offsets_for_adjustment);
return result;
}
std::string UTF16ToUTF8AndAdjustOffsets(
- const base::StringPiece16& utf16,
+ const std::u16string_view& utf16,
std::vector<size_t>* offsets_for_adjustment) {
for (size_t& offset : *offsets_for_adjustment) {
if (offset > utf16.length())
- offset = string16::npos;
+ offset = std::u16string::npos;
}
std::string result;
PrepareForUTF8Output(utf16.data(), utf16.length(), &result);
diff --git a/base/strings/utf_offset_string_conversions.h b/base/strings/utf_offset_string_conversions.h
index b7c4a1b..8d6c5e8 100644
--- a/base/strings/utf_offset_string_conversions.h
+++ b/base/strings/utf_offset_string_conversions.h
@@ -8,11 +8,9 @@
#include <stddef.h>
#include <string>
+#include <string_view>
#include <vector>
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-
namespace base {
// A helper class and associated data structures to adjust offsets into a
@@ -34,7 +32,7 @@
// Adjusts all offsets in |offsets_for_adjustment| to reflect the adjustments
// recorded in |adjustments|. Adjusted offsets greater than |limit| will be
- // set to string16::npos.
+ // set to std::u16string::npos.
//
// Offsets represents insertion/selection points between characters: if |src|
// is "abcd", then 0 is before 'a', 2 is between 'b' and 'c', and 4 is at the
@@ -42,23 +40,24 @@
// exit, each offset will have been modified to point at the same logical
// position in the output string. If an offset cannot be successfully
// adjusted (e.g., because it points into the middle of a multibyte sequence),
- // it will be set to string16::npos.
+ // it will be set to std::u16string::npos.
static void AdjustOffsets(const Adjustments& adjustments,
std::vector<size_t>* offsets_for_adjustment,
- size_t limit = string16::npos);
+ size_t limit = std::u16string::npos);
// Adjusts the single |offset| to reflect the adjustments recorded in
// |adjustments|.
static void AdjustOffset(const Adjustments& adjustments,
size_t* offset,
- size_t limit = string16::npos);
+ size_t limit = std::u16string::npos);
// Adjusts all offsets in |offsets_for_unadjustment| to reflect the reverse
// of the adjustments recorded in |adjustments|. In other words, the offsets
// provided represent offsets into an adjusted string and the caller wants
// to know the offsets they correspond to in the original string. If an
// offset cannot be successfully unadjusted (e.g., because it points into
- // the middle of a multibyte sequence), it will be set to string16::npos.
+ // the middle of a multibyte sequence), it will be set to
+ // std::u16string::npos.
static void UnadjustOffsets(const Adjustments& adjustments,
std::vector<size_t>* offsets_for_unadjustment);
@@ -91,19 +90,20 @@
// It may be NULL.
bool UTF8ToUTF16WithAdjustments(const char* src,
size_t src_len,
- string16* output,
+ std::u16string* output,
base::OffsetAdjuster::Adjustments* adjustments);
-string16 UTF8ToUTF16WithAdjustments(
- const base::StringPiece& utf8,
+std::u16string UTF8ToUTF16WithAdjustments(
+ const std::string_view& utf8,
base::OffsetAdjuster::Adjustments* adjustments);
// 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().
-string16 UTF8ToUTF16AndAdjustOffsets(
- const base::StringPiece& utf8,
+// input string will be set to std::u16string::npos. See comments by
+// AdjustOffsets().
+std::u16string UTF8ToUTF16AndAdjustOffsets(
+ const std::string_view& utf8,
std::vector<size_t>* offsets_for_adjustment);
std::string UTF16ToUTF8AndAdjustOffsets(
- const base::StringPiece16& utf16,
+ const std::u16string_view& utf16,
std::vector<size_t>* offsets_for_adjustment);
} // namespace base
diff --git a/base/strings/utf_string_conversion_utils.cc b/base/strings/utf_string_conversion_utils.cc
index 838471c..32aa3e3 100644
--- a/base/strings/utf_string_conversion_utils.cc
+++ b/base/strings/utf_string_conversion_utils.cc
@@ -75,10 +75,10 @@
return char_offset - original_char_offset;
}
-size_t WriteUnicodeCharacter(uint32_t code_point, string16* output) {
+size_t WriteUnicodeCharacter(uint32_t code_point, std::u16string* output) {
if (CBU16_LENGTH(code_point) == 1) {
// Thie code point is in the Basic Multilingual Plane (BMP).
- output->push_back(static_cast<char16>(code_point));
+ output->push_back(static_cast<char16_t>(code_point));
return 1;
}
// Non-BMP characters use a double-character encoding.
@@ -127,6 +127,6 @@
}
// Instantiate versions we know callers will need.
-template void PrepareForUTF16Or32Output(const char*, size_t, string16*);
+template void PrepareForUTF16Or32Output(const char*, size_t, std::u16string*);
} // namespace base
diff --git a/base/strings/utf_string_conversion_utils.h b/base/strings/utf_string_conversion_utils.h
index 3f14808..e24a7db 100644
--- a/base/strings/utf_string_conversion_utils.h
+++ b/base/strings/utf_string_conversion_utils.h
@@ -11,7 +11,7 @@
#include <stddef.h>
#include <stdint.h>
-#include "base/strings/string16.h"
+#include <string>
namespace base {
@@ -60,7 +60,7 @@
// Appends the given code point as a UTF-16 character to the given 16-bit
// string. Returns the number of 16-bit values written.
-size_t WriteUnicodeCharacter(uint32_t code_point, string16* output);
+size_t WriteUnicodeCharacter(uint32_t code_point, std::u16string* output);
// Generalized Unicode converter -----------------------------------------------
diff --git a/base/strings/utf_string_conversions.cc b/base/strings/utf_string_conversions.cc
index 15f12f6..4b4e420 100644
--- a/base/strings/utf_string_conversions.cc
+++ b/base/strings/utf_string_conversions.cc
@@ -6,7 +6,8 @@
#include <stdint.h>
-#include "base/strings/string_piece.h"
+#include <string_view>
+
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversion_utils.h"
#include "base/third_party/icu/icu_utf.h"
@@ -32,7 +33,7 @@
};
template <>
-struct SizeCoefficient<char16, char> {
+struct SizeCoefficient<char16_t, char> {
// One UTF-16 codeunit corresponds to at most 3 codeunits in UTF-8.
static constexpr int value = 3;
};
@@ -49,7 +50,7 @@
CBU8_APPEND_UNSAFE(out, *size, code_point);
}
-void UnicodeAppendUnsafe(char16* out, int32_t* size, uint32_t code_point) {
+void UnicodeAppendUnsafe(char16_t* out, int32_t* size, uint32_t code_point) {
CBU16_APPEND_UNSAFE(out, *size, code_point);
}
@@ -80,13 +81,13 @@
}
template <typename DestChar>
-bool DoUTFConversion(const char16* src,
+bool DoUTFConversion(const char16_t* src,
int32_t src_len,
DestChar* dest,
int32_t* dest_len) {
bool success = true;
- auto ConvertSingleChar = [&success](char16 in) -> int32_t {
+ auto ConvertSingleChar = [&success](char16_t in) -> int32_t {
if (!CBU16_IS_SINGLE(in) || !IsValidCodepoint(in)) {
success = false;
return kErrorCodePoint;
@@ -155,23 +156,23 @@
// UTF16 <-> UTF8 --------------------------------------------------------------
-bool UTF8ToUTF16(const char* src, size_t src_len, string16* output) {
- return UTFConversion(StringPiece(src, src_len), output);
+bool UTF8ToUTF16(const char* src, size_t src_len, std::u16string* output) {
+ return UTFConversion(std::string_view(src, src_len), output);
}
-string16 UTF8ToUTF16(StringPiece utf8) {
- string16 ret;
+std::u16string UTF8ToUTF16(std::string_view utf8) {
+ std::u16string ret;
// Ignore the success flag of this call, it will do the best it can for
// invalid input, which is what we want here.
UTF8ToUTF16(utf8.data(), utf8.size(), &ret);
return ret;
}
-bool UTF16ToUTF8(const char16* src, size_t src_len, std::string* output) {
- return UTFConversion(StringPiece16(src, src_len), output);
+bool UTF16ToUTF8(const char16_t* src, size_t src_len, std::string* output) {
+ return UTFConversion(std::u16string_view(src, src_len), output);
}
-std::string UTF16ToUTF8(StringPiece16 utf16) {
+std::string UTF16ToUTF8(std::u16string_view utf16) {
std::string ret;
// Ignore the success flag of this call, it will do the best it can for
// invalid input, which is what we want here.
@@ -181,12 +182,12 @@
// ASCII <-> UTF-16 -----------------------------------------------------------
-string16 ASCIIToUTF16(StringPiece ascii) {
+std::u16string ASCIIToUTF16(std::string_view ascii) {
DCHECK(IsStringASCII(ascii)) << ascii;
- return string16(ascii.begin(), ascii.end());
+ return std::u16string(ascii.begin(), ascii.end());
}
-std::string UTF16ToASCII(StringPiece16 utf16) {
+std::string UTF16ToASCII(std::u16string_view utf16) {
DCHECK(IsStringASCII(utf16)) << UTF16ToUTF8(utf16);
return std::string(utf16.begin(), utf16.end());
}
diff --git a/base/strings/utf_string_conversions.h b/base/strings/utf_string_conversions.h
index c4c2b11..116e6a5 100644
--- a/base/strings/utf_string_conversions.h
+++ b/base/strings/utf_string_conversions.h
@@ -8,24 +8,22 @@
#include <stddef.h>
#include <string>
-
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
+#include <string_view>
namespace base {
-bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);
-string16 UTF8ToUTF16(StringPiece utf8);
-bool UTF16ToUTF8(const char16* src, size_t src_len, std::string* output);
-std::string UTF16ToUTF8(StringPiece16 utf16);
+bool UTF8ToUTF16(const char* src, size_t src_len, std::u16string* output);
+std::u16string UTF8ToUTF16(std::string_view utf8);
+bool UTF16ToUTF8(const char16_t* src, size_t src_len, std::string* output);
+std::string UTF16ToUTF8(std::u16string_view utf16);
// This converts an ASCII string, typically a hardcoded constant, to a UTF16
// string.
-string16 ASCIIToUTF16(StringPiece ascii);
+std::u16string ASCIIToUTF16(std::string_view ascii);
// Converts to 7-bit ASCII by truncating. The result must be known to be ASCII
// beforehand.
-std::string UTF16ToASCII(StringPiece16 utf16);
+std::string UTF16ToASCII(std::u16string_view utf16);
} // namespace base
diff --git a/base/values.cc b/base/values.cc
index 0b348b7..9c34803 100644
--- a/base/values.cc
+++ b/base/values.cc
@@ -130,16 +130,18 @@
Value::Value(const char* in_string) : Value(std::string(in_string)) {}
-Value::Value(StringPiece in_string) : Value(std::string(in_string)) {}
+Value::Value(std::string_view in_string) : Value(std::string(in_string)) {}
Value::Value(std::string&& in_string) noexcept
: type_(Type::STRING), string_value_(std::move(in_string)) {
DCHECK(IsStringUTF8(string_value_));
}
-Value::Value(const char16* in_string16) : Value(StringPiece16(in_string16)) {}
+Value::Value(const char16_t* in_string16)
+ : Value(std::u16string_view(in_string16)) {}
-Value::Value(StringPiece16 in_string16) : Value(UTF16ToUTF8(in_string16)) {}
+Value::Value(std::u16string_view in_string16)
+ : Value(UTF16ToUTF8(in_string16)) {}
Value::Value(const BlobStorage& in_blob)
: type_(Type::BINARY), binary_value_(in_blob) {}
@@ -237,11 +239,11 @@
return list_;
}
-Value* Value::FindKey(StringPiece key) {
+Value* Value::FindKey(std::string_view key) {
return const_cast<Value*>(static_cast<const Value*>(this)->FindKey(key));
}
-const Value* Value::FindKey(StringPiece key) const {
+const Value* Value::FindKey(std::string_view key) const {
CHECK(is_dict());
auto found = dict_.find(key);
if (found == dict_.end())
@@ -249,28 +251,28 @@
return found->second.get();
}
-Value* Value::FindKeyOfType(StringPiece key, Type type) {
+Value* Value::FindKeyOfType(std::string_view key, Type type) {
return const_cast<Value*>(
static_cast<const Value*>(this)->FindKeyOfType(key, type));
}
-const Value* Value::FindKeyOfType(StringPiece key, Type type) const {
+const Value* Value::FindKeyOfType(std::string_view key, Type type) const {
const Value* result = FindKey(key);
if (!result || result->type() != type)
return nullptr;
return result;
}
-bool Value::RemoveKey(StringPiece key) {
+bool Value::RemoveKey(std::string_view key) {
CHECK(is_dict());
// NOTE: Can't directly return dict_->erase(key) due to MSVC warning C4800.
return dict_.erase(key) != 0;
}
-Value* Value::SetKey(StringPiece key, Value value) {
+Value* Value::SetKey(std::string_view key, Value value) {
CHECK(is_dict());
// NOTE: We can't use |insert_or_assign| here, as only |try_emplace| does
- // an explicit conversion from StringPiece to std::string if necessary.
+ // an explicit conversion from std::string_view to std::string if necessary.
auto val_ptr = std::make_unique<Value>(std::move(value));
auto result = dict_.try_emplace(key, std::move(val_ptr));
if (!result.second) {
@@ -289,49 +291,50 @@
}
Value* Value::SetKey(const char* key, Value value) {
- return SetKey(StringPiece(key), std::move(value));
+ return SetKey(std::string_view(key), std::move(value));
}
-Value* Value::FindPath(std::initializer_list<StringPiece> path) {
+Value* Value::FindPath(std::initializer_list<std::string_view> path) {
return const_cast<Value*>(const_cast<const Value*>(this)->FindPath(path));
}
-Value* Value::FindPath(span<const StringPiece> path) {
+Value* Value::FindPath(span<const std::string_view> path) {
return const_cast<Value*>(const_cast<const Value*>(this)->FindPath(path));
}
-const Value* Value::FindPath(std::initializer_list<StringPiece> path) const {
+const Value* Value::FindPath(
+ std::initializer_list<std::string_view> path) const {
DCHECK_GE(path.size(), 2u) << "Use FindKey() for a path of length 1.";
return FindPath(make_span(path.begin(), path.size()));
}
-const Value* Value::FindPath(span<const StringPiece> path) const {
+const Value* Value::FindPath(span<const std::string_view> path) const {
const Value* cur = this;
- for (const StringPiece component : path) {
+ for (const std::string_view component : path) {
if (!cur->is_dict() || (cur = cur->FindKey(component)) == nullptr)
return nullptr;
}
return cur;
}
-Value* Value::FindPathOfType(std::initializer_list<StringPiece> path,
+Value* Value::FindPathOfType(std::initializer_list<std::string_view> path,
Type type) {
return const_cast<Value*>(
const_cast<const Value*>(this)->FindPathOfType(path, type));
}
-Value* Value::FindPathOfType(span<const StringPiece> path, Type type) {
+Value* Value::FindPathOfType(span<const std::string_view> path, Type type) {
return const_cast<Value*>(
const_cast<const Value*>(this)->FindPathOfType(path, type));
}
-const Value* Value::FindPathOfType(std::initializer_list<StringPiece> path,
+const Value* Value::FindPathOfType(std::initializer_list<std::string_view> path,
Type type) const {
DCHECK_GE(path.size(), 2u) << "Use FindKeyOfType() for a path of length 1.";
return FindPathOfType(make_span(path.begin(), path.size()), type);
}
-const Value* Value::FindPathOfType(span<const StringPiece> path,
+const Value* Value::FindPathOfType(span<const std::string_view> path,
Type type) const {
const Value* result = FindPath(path);
if (!result || result->type() != type)
@@ -339,24 +342,25 @@
return result;
}
-Value* Value::SetPath(std::initializer_list<StringPiece> path, Value value) {
+Value* Value::SetPath(std::initializer_list<std::string_view> path,
+ Value value) {
DCHECK_GE(path.size(), 2u) << "Use SetKey() for a path of length 1.";
return SetPath(make_span(path.begin(), path.size()), std::move(value));
}
-Value* Value::SetPath(span<const StringPiece> path, Value value) {
+Value* Value::SetPath(span<const std::string_view> path, Value value) {
DCHECK_NE(path.begin(), path.end()); // Can't be empty path.
// Walk/construct intermediate dictionaries. The last element requires
// special handling so skip it in this loop.
Value* cur = this;
- const StringPiece* cur_path = path.begin();
+ const std::string_view* cur_path = path.begin();
for (; (cur_path + 1) < path.end(); ++cur_path) {
if (!cur->is_dict())
return nullptr;
// Use lower_bound to avoid doing the search twice for missing keys.
- const StringPiece path_component = *cur_path;
+ const std::string_view path_component = *cur_path;
auto found = cur->dict_.lower_bound(path_component);
if (found == cur->dict_.end() || found->first != path_component) {
// No key found, insert one.
@@ -374,12 +378,12 @@
return cur->SetKey(*cur_path, std::move(value));
}
-bool Value::RemovePath(std::initializer_list<StringPiece> path) {
+bool Value::RemovePath(std::initializer_list<std::string_view> path) {
DCHECK_GE(path.size(), 2u) << "Use RemoveKey() for a path of length 1.";
return RemovePath(make_span(path.begin(), path.size()));
}
-bool Value::RemovePath(span<const StringPiece> path) {
+bool Value::RemovePath(span<const std::string_view> path) {
if (!is_dict() || path.empty())
return false;
@@ -441,7 +445,7 @@
return is_string();
}
-bool Value::GetAsString(string16* out_value) const {
+bool Value::GetAsString(std::u16string* out_value) const {
if (out_value && is_string()) {
*out_value = UTF8ToUTF16(string_value_);
return true;
@@ -457,7 +461,7 @@
return is_string();
}
-bool Value::GetAsString(StringPiece* out_value) const {
+bool Value::GetAsString(std::string_view* out_value) const {
if (out_value && is_string()) {
*out_value = string_value_;
return true;
@@ -660,7 +664,7 @@
DictionaryValue::DictionaryValue(DictStorage&& in_dict) noexcept
: Value(std::move(in_dict)) {}
-bool DictionaryValue::HasKey(StringPiece key) const {
+bool DictionaryValue::HasKey(std::string_view key) const {
DCHECK(IsStringUTF8(key));
auto current_entry = dict_.find(key);
DCHECK((current_entry == dict_.end()) || current_entry->second);
@@ -671,17 +675,18 @@
dict_.clear();
}
-Value* DictionaryValue::Set(StringPiece path, std::unique_ptr<Value> in_value) {
+Value* DictionaryValue::Set(std::string_view path,
+ std::unique_ptr<Value> in_value) {
DCHECK(IsStringUTF8(path));
DCHECK(in_value);
- StringPiece current_path(path);
+ std::string_view current_path(path);
Value* current_dictionary = this;
for (size_t delimiter_position = current_path.find('.');
- delimiter_position != StringPiece::npos;
+ delimiter_position != std::string_view::npos;
delimiter_position = current_path.find('.')) {
// Assume that we're indexing into a dictionary.
- StringPiece key = current_path.substr(0, delimiter_position);
+ std::string_view key = current_path.substr(0, delimiter_position);
Value* child_dictionary =
current_dictionary->FindKeyOfType(key, Type::DICTIONARY);
if (!child_dictionary) {
@@ -697,38 +702,40 @@
->SetWithoutPathExpansion(current_path, std::move(in_value));
}
-Value* DictionaryValue::SetBoolean(StringPiece path, bool in_value) {
+Value* DictionaryValue::SetBoolean(std::string_view path, bool in_value) {
return Set(path, std::make_unique<Value>(in_value));
}
-Value* DictionaryValue::SetInteger(StringPiece path, int in_value) {
+Value* DictionaryValue::SetInteger(std::string_view path, int in_value) {
return Set(path, std::make_unique<Value>(in_value));
}
-Value* DictionaryValue::SetString(StringPiece path, StringPiece in_value) {
+Value* DictionaryValue::SetString(std::string_view path,
+ std::string_view in_value) {
return Set(path, std::make_unique<Value>(in_value));
}
-Value* DictionaryValue::SetString(StringPiece path, const string16& in_value) {
+Value* DictionaryValue::SetString(std::string_view path,
+ const std::u16string& in_value) {
return Set(path, std::make_unique<Value>(in_value));
}
DictionaryValue* DictionaryValue::SetDictionary(
- StringPiece path,
+ std::string_view path,
std::unique_ptr<DictionaryValue> in_value) {
return static_cast<DictionaryValue*>(Set(path, std::move(in_value)));
}
-ListValue* DictionaryValue::SetList(StringPiece path,
+ListValue* DictionaryValue::SetList(std::string_view path,
std::unique_ptr<ListValue> in_value) {
return static_cast<ListValue*>(Set(path, std::move(in_value)));
}
Value* DictionaryValue::SetWithoutPathExpansion(
- StringPiece key,
+ std::string_view key,
std::unique_ptr<Value> in_value) {
// NOTE: We can't use |insert_or_assign| here, as only |try_emplace| does
- // an explicit conversion from StringPiece to std::string if necessary.
+ // an explicit conversion from std::string_view to std::string if necessary.
auto result = dict_.try_emplace(key, std::move(in_value));
if (!result.second) {
// in_value is guaranteed to be still intact at this point.
@@ -737,9 +744,10 @@
return result.first->second.get();
}
-bool DictionaryValue::Get(StringPiece path, const Value** out_value) const {
+bool DictionaryValue::Get(std::string_view path,
+ const Value** out_value) const {
DCHECK(IsStringUTF8(path));
- StringPiece current_path(path);
+ std::string_view current_path(path);
const DictionaryValue* current_dictionary = this;
for (size_t delimiter_position = current_path.find('.');
delimiter_position != std::string::npos;
@@ -757,12 +765,13 @@
return current_dictionary->GetWithoutPathExpansion(current_path, out_value);
}
-bool DictionaryValue::Get(StringPiece path, Value** out_value) {
+bool DictionaryValue::Get(std::string_view path, Value** out_value) {
return static_cast<const DictionaryValue&>(*this).Get(
path, const_cast<const Value**>(out_value));
}
-bool DictionaryValue::GetBoolean(StringPiece path, bool* bool_value) const {
+bool DictionaryValue::GetBoolean(std::string_view path,
+ bool* bool_value) const {
const Value* value;
if (!Get(path, &value))
return false;
@@ -770,7 +779,7 @@
return value->GetAsBoolean(bool_value);
}
-bool DictionaryValue::GetInteger(StringPiece path, int* out_value) const {
+bool DictionaryValue::GetInteger(std::string_view path, int* out_value) const {
const Value* value;
if (!Get(path, &value))
return false;
@@ -778,7 +787,7 @@
return value->GetAsInteger(out_value);
}
-bool DictionaryValue::GetString(StringPiece path,
+bool DictionaryValue::GetString(std::string_view path,
std::string* out_value) const {
const Value* value;
if (!Get(path, &value))
@@ -787,7 +796,8 @@
return value->GetAsString(out_value);
}
-bool DictionaryValue::GetString(StringPiece path, string16* out_value) const {
+bool DictionaryValue::GetString(std::string_view path,
+ std::u16string* out_value) const {
const Value* value;
if (!Get(path, &value))
return false;
@@ -795,7 +805,7 @@
return value->GetAsString(out_value);
}
-bool DictionaryValue::GetStringASCII(StringPiece path,
+bool DictionaryValue::GetStringASCII(std::string_view path,
std::string* out_value) const {
std::string out;
if (!GetString(path, &out))
@@ -810,7 +820,7 @@
return true;
}
-bool DictionaryValue::GetBinary(StringPiece path,
+bool DictionaryValue::GetBinary(std::string_view path,
const Value** out_value) const {
const Value* value;
bool result = Get(path, &value);
@@ -823,12 +833,12 @@
return true;
}
-bool DictionaryValue::GetBinary(StringPiece path, Value** out_value) {
+bool DictionaryValue::GetBinary(std::string_view path, Value** out_value) {
return static_cast<const DictionaryValue&>(*this).GetBinary(
path, const_cast<const Value**>(out_value));
}
-bool DictionaryValue::GetDictionary(StringPiece path,
+bool DictionaryValue::GetDictionary(std::string_view path,
const DictionaryValue** out_value) const {
const Value* value;
bool result = Get(path, &value);
@@ -841,13 +851,13 @@
return true;
}
-bool DictionaryValue::GetDictionary(StringPiece path,
+bool DictionaryValue::GetDictionary(std::string_view path,
DictionaryValue** out_value) {
return static_cast<const DictionaryValue&>(*this).GetDictionary(
path, const_cast<const DictionaryValue**>(out_value));
}
-bool DictionaryValue::GetList(StringPiece path,
+bool DictionaryValue::GetList(std::string_view path,
const ListValue** out_value) const {
const Value* value;
bool result = Get(path, &value);
@@ -860,12 +870,12 @@
return true;
}
-bool DictionaryValue::GetList(StringPiece path, ListValue** out_value) {
+bool DictionaryValue::GetList(std::string_view path, ListValue** out_value) {
return static_cast<const DictionaryValue&>(*this).GetList(
path, const_cast<const ListValue**>(out_value));
}
-bool DictionaryValue::GetWithoutPathExpansion(StringPiece key,
+bool DictionaryValue::GetWithoutPathExpansion(std::string_view key,
const Value** out_value) const {
DCHECK(IsStringUTF8(key));
auto entry_iterator = dict_.find(key);
@@ -877,13 +887,13 @@
return true;
}
-bool DictionaryValue::GetWithoutPathExpansion(StringPiece key,
+bool DictionaryValue::GetWithoutPathExpansion(std::string_view key,
Value** out_value) {
return static_cast<const DictionaryValue&>(*this).GetWithoutPathExpansion(
key, const_cast<const Value**>(out_value));
}
-bool DictionaryValue::GetBooleanWithoutPathExpansion(StringPiece key,
+bool DictionaryValue::GetBooleanWithoutPathExpansion(std::string_view key,
bool* out_value) const {
const Value* value;
if (!GetWithoutPathExpansion(key, &value))
@@ -892,7 +902,7 @@
return value->GetAsBoolean(out_value);
}
-bool DictionaryValue::GetIntegerWithoutPathExpansion(StringPiece key,
+bool DictionaryValue::GetIntegerWithoutPathExpansion(std::string_view key,
int* out_value) const {
const Value* value;
if (!GetWithoutPathExpansion(key, &value))
@@ -902,7 +912,7 @@
}
bool DictionaryValue::GetStringWithoutPathExpansion(
- StringPiece key,
+ std::string_view key,
std::string* out_value) const {
const Value* value;
if (!GetWithoutPathExpansion(key, &value))
@@ -911,8 +921,9 @@
return value->GetAsString(out_value);
}
-bool DictionaryValue::GetStringWithoutPathExpansion(StringPiece key,
- string16* out_value) const {
+bool DictionaryValue::GetStringWithoutPathExpansion(
+ std::string_view key,
+ std::u16string* out_value) const {
const Value* value;
if (!GetWithoutPathExpansion(key, &value))
return false;
@@ -921,7 +932,7 @@
}
bool DictionaryValue::GetDictionaryWithoutPathExpansion(
- StringPiece key,
+ std::string_view key,
const DictionaryValue** out_value) const {
const Value* value;
bool result = GetWithoutPathExpansion(key, &value);
@@ -935,7 +946,7 @@
}
bool DictionaryValue::GetDictionaryWithoutPathExpansion(
- StringPiece key,
+ std::string_view key,
DictionaryValue** out_value) {
const DictionaryValue& const_this =
static_cast<const DictionaryValue&>(*this);
@@ -944,7 +955,7 @@
}
bool DictionaryValue::GetListWithoutPathExpansion(
- StringPiece key,
+ std::string_view key,
const ListValue** out_value) const {
const Value* value;
bool result = GetWithoutPathExpansion(key, &value);
@@ -957,19 +968,19 @@
return true;
}
-bool DictionaryValue::GetListWithoutPathExpansion(StringPiece key,
+bool DictionaryValue::GetListWithoutPathExpansion(std::string_view key,
ListValue** out_value) {
return static_cast<const DictionaryValue&>(*this).GetListWithoutPathExpansion(
key, const_cast<const ListValue**>(out_value));
}
-bool DictionaryValue::Remove(StringPiece path,
+bool DictionaryValue::Remove(std::string_view path,
std::unique_ptr<Value>* out_value) {
DCHECK(IsStringUTF8(path));
- StringPiece current_path(path);
+ std::string_view current_path(path);
DictionaryValue* current_dictionary = this;
size_t delimiter_position = current_path.rfind('.');
- if (delimiter_position != StringPiece::npos) {
+ if (delimiter_position != std::string_view::npos) {
if (!GetDictionary(current_path.substr(0, delimiter_position),
¤t_dictionary))
return false;
@@ -981,7 +992,7 @@
}
bool DictionaryValue::RemoveWithoutPathExpansion(
- StringPiece key,
+ std::string_view key,
std::unique_ptr<Value>* out_value) {
DCHECK(IsStringUTF8(key));
auto entry_iterator = dict_.find(key);
@@ -994,7 +1005,7 @@
return true;
}
-bool DictionaryValue::RemovePath(StringPiece path,
+bool DictionaryValue::RemovePath(std::string_view path,
std::unique_ptr<Value>* out_value) {
bool result = false;
size_t delimiter_position = path.find('.');
@@ -1002,7 +1013,7 @@
if (delimiter_position == std::string::npos)
return RemoveWithoutPathExpansion(path, out_value);
- StringPiece subdict_path = path.substr(0, delimiter_position);
+ std::string_view subdict_path = path.substr(0, delimiter_position);
DictionaryValue* subdict = nullptr;
if (!GetDictionary(subdict_path, &subdict))
return false;
@@ -1135,7 +1146,7 @@
return value->GetAsString(out_value);
}
-bool ListValue::GetString(size_t index, string16* out_value) const {
+bool ListValue::GetString(size_t index, std::u16string* out_value) const {
const Value* value;
if (!Get(index, &value))
return false;
@@ -1222,11 +1233,11 @@
list_.emplace_back(in_value);
}
-void ListValue::AppendString(StringPiece in_value) {
+void ListValue::AppendString(std::string_view in_value) {
list_.emplace_back(in_value);
}
-void ListValue::AppendString(const string16& in_value) {
+void ListValue::AppendString(const std::u16string& in_value) {
list_.emplace_back(in_value);
}
@@ -1236,7 +1247,7 @@
list_.emplace_back(in_value);
}
-void ListValue::AppendStrings(const std::vector<string16>& in_values) {
+void ListValue::AppendStrings(const std::vector<std::u16string>& in_values) {
list_.reserve(list_.size() + in_values.size());
for (const auto& in_value : in_values)
list_.emplace_back(in_value);
diff --git a/base/values.h b/base/values.h
index c3ec875..b32c8f9 100644
--- a/base/values.h
+++ b/base/values.h
@@ -27,14 +27,13 @@
#include <map>
#include <memory>
#include <string>
+#include <string_view>
#include <utility>
#include <vector>
#include "base/containers/flat_map.h"
#include "base/containers/span.h"
#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
#include "base/value_iterators.h"
namespace base {
@@ -116,15 +115,15 @@
explicit Value(bool in_bool);
explicit Value(int in_int);
- // Value(const char*) and Value(const char16*) are required despite
- // Value(StringPiece) and Value(StringPiece16) because otherwise the
- // compiler will choose the Value(bool) constructor for these arguments.
+ // Value(const char*) and Value(const char16_t*) are required despite
+ // Value(std::string_view) and Value(std::u16string_view) because otherwise
+ // the compiler will choose the Value(bool) constructor for these arguments.
// Value(std::string&&) allow for efficient move construction.
explicit Value(const char* in_string);
- explicit Value(StringPiece in_string);
+ explicit Value(std::string_view in_string);
explicit Value(std::string&& in_string) noexcept;
- explicit Value(const char16* in_string16);
- explicit Value(StringPiece16 in_string16);
+ explicit Value(const char16_t* in_string16);
+ explicit Value(std::u16string_view in_string16);
explicit Value(const BlobStorage& in_blob);
explicit Value(BlobStorage&& in_blob) noexcept;
@@ -171,8 +170,8 @@
//
// Example:
// auto* found = FindKey("foo");
- Value* FindKey(StringPiece key);
- const Value* FindKey(StringPiece key) const;
+ Value* FindKey(std::string_view key);
+ const Value* FindKey(std::string_view key) const;
// |FindKeyOfType| is similar to |FindKey|, but it also requires the found
// value to have type |type|. If no type is found, or the found value is of a
@@ -183,8 +182,8 @@
//
// Example:
// auto* found = FindKey("foo", Type::INTEGER);
- Value* FindKeyOfType(StringPiece key, Type type);
- const Value* FindKeyOfType(StringPiece key, Type type) const;
+ Value* FindKeyOfType(std::string_view key, Type type);
+ const Value* FindKeyOfType(std::string_view key, Type type) const;
// |SetKey| looks up |key| in the underlying dictionary and sets the mapped
// value to |value|. If |key| could not be found, a new element is inserted.
@@ -193,7 +192,7 @@
//
// Example:
// SetKey("foo", std::move(myvalue));
- Value* SetKey(StringPiece key, Value value);
+ Value* SetKey(std::string_view key, Value value);
// This overload results in a performance improvement for std::string&&.
Value* SetKey(std::string&& key, Value value);
// This overload is necessary to avoid ambiguity for const char* arguments.
@@ -207,7 +206,7 @@
//
// Example:
// bool success = RemoveKey("foo");
- bool RemoveKey(StringPiece key);
+ bool RemoveKey(std::string_view key);
// Searches a hierarchy of dictionary values for a given value. If a path
// of dictionaries exist, returns the item at that path. If any of the path
@@ -223,25 +222,27 @@
// Example:
// auto* found = FindPath({"foo", "bar"});
//
- // std::vector<StringPiece> components = ...
+ // std::vector<std::string_view> components = ...
// auto* found = FindPath(components);
//
// Note: If there is only one component in the path, use FindKey() instead.
- Value* FindPath(std::initializer_list<StringPiece> path);
- Value* FindPath(span<const StringPiece> path);
- const Value* FindPath(std::initializer_list<StringPiece> path) const;
- const Value* FindPath(span<const StringPiece> path) const;
+ Value* FindPath(std::initializer_list<std::string_view> path);
+ Value* FindPath(span<const std::string_view> path);
+ const Value* FindPath(std::initializer_list<std::string_view> path) const;
+ const Value* FindPath(span<const std::string_view> path) const;
// Like FindPath() but will only return the value if the leaf Value type
// matches the given type. Will return nullptr otherwise.
//
// Note: If there is only one component in the path, use FindKeyOfType()
// instead.
- Value* FindPathOfType(std::initializer_list<StringPiece> path, Type type);
- Value* FindPathOfType(span<const StringPiece> path, Type type);
- const Value* FindPathOfType(std::initializer_list<StringPiece> path,
+ Value* FindPathOfType(std::initializer_list<std::string_view> path,
+ Type type);
+ Value* FindPathOfType(span<const std::string_view> path, Type type);
+ const Value* FindPathOfType(std::initializer_list<std::string_view> path,
Type type) const;
- const Value* FindPathOfType(span<const StringPiece> path, Type type) const;
+ const Value* FindPathOfType(span<const std::string_view> path,
+ Type type) const;
// Sets the given path, expanding and creating dictionary keys as necessary.
//
@@ -255,12 +256,12 @@
// Example:
// value.SetPath({"foo", "bar"}, std::move(myvalue));
//
- // std::vector<StringPiece> components = ...
+ // std::vector<std::string_view> components = ...
// value.SetPath(components, std::move(myvalue));
//
// Note: If there is only one component in the path, use SetKey() instead.
- Value* SetPath(std::initializer_list<StringPiece> path, Value value);
- Value* SetPath(span<const StringPiece> path, Value value);
+ Value* SetPath(std::initializer_list<std::string_view> path, Value value);
+ Value* SetPath(span<const std::string_view> path, Value value);
// Tries to remove a Value at the given path.
//
@@ -272,12 +273,12 @@
// Example:
// bool success = value.RemovePath({"foo", "bar"});
//
- // std::vector<StringPiece> components = ...
+ // std::vector<std::string_view> components = ...
// bool success = value.RemovePath(components);
//
// Note: If there is only one component in the path, use RemoveKey() instead.
- bool RemovePath(std::initializer_list<StringPiece> path);
- bool RemovePath(span<const StringPiece> path);
+ bool RemovePath(std::initializer_list<std::string_view> path);
+ bool RemovePath(span<const std::string_view> path);
using dict_iterator_proxy = detail::dict_iterator_proxy;
using const_dict_iterator_proxy = detail::const_dict_iterator_proxy;
@@ -305,9 +306,9 @@
bool GetAsInteger(int* out_value) const;
// DEPRECATED, use GetString() instead.
bool GetAsString(std::string* out_value) const;
- bool GetAsString(string16* out_value) const;
+ bool GetAsString(std::u16string* out_value) const;
bool GetAsString(const Value** out_value) const;
- bool GetAsString(StringPiece* out_value) const;
+ bool GetAsString(std::string_view* out_value) const;
// ListValue::From is the equivalent for std::unique_ptr conversions.
// DEPRECATED, use GetList() instead.
bool GetAsList(ListValue** out_value);
@@ -384,7 +385,7 @@
// Returns true if the current dictionary has a value for the given key.
// DEPRECATED, use Value::FindKey(key) instead.
- bool HasKey(StringPiece key) const;
+ bool HasKey(std::string_view key) const;
// Returns the number of Values in this dictionary.
size_t size() const { return dict_.size(); }
@@ -404,28 +405,29 @@
// to the path in that location. |in_value| must be non-null.
// Returns a pointer to the inserted value.
// DEPRECATED, use Value::SetPath(path, value) instead.
- Value* Set(StringPiece path, std::unique_ptr<Value> in_value);
+ Value* Set(std::string_view path, std::unique_ptr<Value> in_value);
// Convenience forms of Set(). These methods will replace any existing
// value at that path, even if it has a different type.
// DEPRECATED, use Value::SetPath(path, Value(bool)) instead.
- Value* SetBoolean(StringPiece path, bool in_value);
+ Value* SetBoolean(std::string_view path, bool in_value);
// DEPRECATED, use Value::SetPath(path, Value(int)) instead.
- Value* SetInteger(StringPiece path, int in_value);
- // DEPRECATED, use Value::SetPath(path, Value(StringPiece)) instead.
- Value* SetString(StringPiece path, StringPiece in_value);
+ Value* SetInteger(std::string_view path, int in_value);
+ // DEPRECATED, use Value::SetPath(path, Value(std::string_view)) instead.
+ Value* SetString(std::string_view path, std::string_view in_value);
// DEPRECATED, use Value::SetPath(path, Value(const string& 16)) instead.
- Value* SetString(StringPiece path, const string16& in_value);
+ Value* SetString(std::string_view path, const std::u16string& in_value);
// DEPRECATED, use Value::SetPath(path, Value(Type::DICTIONARY)) instead.
- DictionaryValue* SetDictionary(StringPiece path,
+ DictionaryValue* SetDictionary(std::string_view path,
std::unique_ptr<DictionaryValue> in_value);
// DEPRECATED, use Value::SetPath(path, Value(Type::LIST)) instead.
- ListValue* SetList(StringPiece path, std::unique_ptr<ListValue> in_value);
+ ListValue* SetList(std::string_view path,
+ std::unique_ptr<ListValue> in_value);
// Like Set(), but without special treatment of '.'. This allows e.g. URLs to
// be used as paths.
// DEPRECATED, use Value::SetKey(key, value) instead.
- Value* SetWithoutPathExpansion(StringPiece key,
+ Value* SetWithoutPathExpansion(std::string_view key,
std::unique_ptr<Value> in_value);
// Gets the Value associated with the given path starting from this object.
@@ -437,65 +439,69 @@
// Note that the dictionary always owns the value that's returned.
// |out_value| is optional and will only be set if non-NULL.
// DEPRECATED, use Value::FindPath(path) instead.
- bool Get(StringPiece path, const Value** out_value) const;
+ bool Get(std::string_view path, const Value** out_value) const;
// DEPRECATED, use Value::FindPath(path) instead.
- bool Get(StringPiece path, Value** out_value);
+ bool Get(std::string_view path, Value** out_value);
// These are convenience forms of Get(). The value will be retrieved
// and the return value will be true if the path is valid and the value at
// the end of the path can be returned in the form specified.
// |out_value| is optional and will only be set if non-NULL.
// DEPRECATED, use Value::FindPath(path) and Value::GetBool() instead.
- bool GetBoolean(StringPiece path, bool* out_value) const;
+ bool GetBoolean(std::string_view path, bool* out_value) const;
// DEPRECATED, use Value::FindPath(path) and Value::GetInt() instead.
- bool GetInteger(StringPiece path, int* out_value) const;
+ bool GetInteger(std::string_view path, int* out_value) const;
// DEPRECATED, use Value::FindPath(path) and Value::GetString() instead.
- bool GetString(StringPiece path, std::string* out_value) const;
+ bool GetString(std::string_view path, std::string* out_value) const;
// DEPRECATED, use Value::FindPath(path) and Value::GetString() instead.
- bool GetString(StringPiece path, string16* out_value) const;
+ bool GetString(std::string_view path, std::u16string* out_value) const;
// DEPRECATED, use Value::FindPath(path) and Value::GetString() instead.
- bool GetStringASCII(StringPiece path, std::string* out_value) const;
+ bool GetStringASCII(std::string_view path, std::string* out_value) const;
// DEPRECATED, use Value::FindPath(path) and Value::GetBlob() instead.
- bool GetBinary(StringPiece path, const Value** out_value) const;
+ bool GetBinary(std::string_view path, const Value** out_value) const;
// DEPRECATED, use Value::FindPath(path) and Value::GetBlob() instead.
- bool GetBinary(StringPiece path, Value** out_value);
+ bool GetBinary(std::string_view path, Value** out_value);
// DEPRECATED, use Value::FindPath(path) and Value's Dictionary API instead.
- bool GetDictionary(StringPiece path, const DictionaryValue** out_value) const;
+ bool GetDictionary(std::string_view path,
+ const DictionaryValue** out_value) const;
// DEPRECATED, use Value::FindPath(path) and Value's Dictionary API instead.
- bool GetDictionary(StringPiece path, DictionaryValue** out_value);
+ bool GetDictionary(std::string_view path, DictionaryValue** out_value);
// DEPRECATED, use Value::FindPath(path) and Value::GetList() instead.
- bool GetList(StringPiece path, const ListValue** out_value) const;
+ bool GetList(std::string_view path, const ListValue** out_value) const;
// DEPRECATED, use Value::FindPath(path) and Value::GetList() instead.
- bool GetList(StringPiece path, ListValue** out_value);
+ bool GetList(std::string_view path, ListValue** out_value);
// Like Get(), but without special treatment of '.'. This allows e.g. URLs to
// be used as paths.
// DEPRECATED, use Value::FindKey(key) instead.
- bool GetWithoutPathExpansion(StringPiece key, const Value** out_value) const;
+ bool GetWithoutPathExpansion(std::string_view key,
+ const Value** out_value) const;
// DEPRECATED, use Value::FindKey(key) instead.
- bool GetWithoutPathExpansion(StringPiece key, Value** out_value);
+ bool GetWithoutPathExpansion(std::string_view key, Value** out_value);
// DEPRECATED, use Value::FindKey(key) and Value::GetBool() instead.
- bool GetBooleanWithoutPathExpansion(StringPiece key, bool* out_value) const;
+ bool GetBooleanWithoutPathExpansion(std::string_view key,
+ bool* out_value) const;
// DEPRECATED, use Value::FindKey(key) and Value::GetInt() instead.
- bool GetIntegerWithoutPathExpansion(StringPiece key, int* out_value) const;
+ bool GetIntegerWithoutPathExpansion(std::string_view key,
+ int* out_value) const;
// DEPRECATED, use Value::FindKey(key) and Value::GetString() instead.
- bool GetStringWithoutPathExpansion(StringPiece key,
+ bool GetStringWithoutPathExpansion(std::string_view key,
std::string* out_value) const;
// DEPRECATED, use Value::FindKey(key) and Value::GetString() instead.
- bool GetStringWithoutPathExpansion(StringPiece key,
- string16* out_value) const;
+ bool GetStringWithoutPathExpansion(std::string_view key,
+ std::u16string* out_value) const;
// DEPRECATED, use Value::FindKey(key) and Value's Dictionary API instead.
bool GetDictionaryWithoutPathExpansion(
- StringPiece key,
+ std::string_view key,
const DictionaryValue** out_value) const;
// DEPRECATED, use Value::FindKey(key) and Value's Dictionary API instead.
- bool GetDictionaryWithoutPathExpansion(StringPiece key,
+ bool GetDictionaryWithoutPathExpansion(std::string_view key,
DictionaryValue** out_value);
// DEPRECATED, use Value::FindKey(key) and Value::GetList() instead.
- bool GetListWithoutPathExpansion(StringPiece key,
+ bool GetListWithoutPathExpansion(std::string_view key,
const ListValue** out_value) const;
// DEPRECATED, use Value::FindKey(key) and Value::GetList() instead.
- bool GetListWithoutPathExpansion(StringPiece key, ListValue** out_value);
+ bool GetListWithoutPathExpansion(std::string_view key, ListValue** out_value);
// Removes the Value with the specified path from this dictionary (or one
// of its child dictionaries, if the path is more than just a local key).
@@ -504,18 +510,18 @@
// This method returns true if |path| is a valid path; otherwise it will
// return false and the DictionaryValue object will be unchanged.
// DEPRECATED, use Value::RemovePath(path) instead.
- bool Remove(StringPiece path, std::unique_ptr<Value>* out_value);
+ bool Remove(std::string_view path, std::unique_ptr<Value>* out_value);
// Like Remove(), but without special treatment of '.'. This allows e.g. URLs
// to be used as paths.
// DEPRECATED, use Value::RemoveKey(key) instead.
- bool RemoveWithoutPathExpansion(StringPiece key,
+ bool RemoveWithoutPathExpansion(std::string_view key,
std::unique_ptr<Value>* out_value);
// Removes a path, clearing out all dictionaries on |path| that remain empty
// after removing the value at |path|.
// DEPRECATED, use Value::RemovePath(path) instead.
- bool RemovePath(StringPiece path, std::unique_ptr<Value>* out_value);
+ bool RemovePath(std::string_view path, std::unique_ptr<Value>* out_value);
using Value::RemovePath; // DictionaryValue::RemovePath shadows otherwise.
@@ -625,7 +631,7 @@
bool GetInteger(size_t index, int* out_value) const;
// DEPRECATED, use GetList()::operator[]::GetString() instead.
bool GetString(size_t index, std::string* out_value) const;
- bool GetString(size_t index, string16* out_value) const;
+ bool GetString(size_t index, std::u16string* out_value) const;
bool GetDictionary(size_t index, const DictionaryValue** out_value) const;
bool GetDictionary(size_t index, DictionaryValue** out_value);
@@ -664,11 +670,11 @@
// DEPRECATED, use GetList()::emplace_back() instead.
void AppendBoolean(bool in_value);
void AppendInteger(int in_value);
- void AppendString(StringPiece in_value);
- void AppendString(const string16& in_value);
+ void AppendString(std::string_view in_value);
+ void AppendString(const std::u16string& in_value);
// DEPRECATED, use GetList()::emplace_back() in a loop instead.
void AppendStrings(const std::vector<std::string>& in_values);
- void AppendStrings(const std::vector<string16>& in_values);
+ void AppendStrings(const std::vector<std::u16string>& in_values);
// Appends a Value if it's not already present. Returns true if successful,
// or false if the value was already
diff --git a/tools/gn/args.cc b/tools/gn/args.cc
index 802c373..e14adf6 100644
--- a/tools/gn/args.cc
+++ b/tools/gn/args.cc
@@ -108,8 +108,8 @@
void Args::AddArgOverride(const char* name, const Value& value) {
std::lock_guard<std::mutex> lock(lock_);
- overrides_[base::StringPiece(name)] = value;
- all_overrides_[base::StringPiece(name)] = value;
+ overrides_[std::string_view(name)] = value;
+ all_overrides_[std::string_view(name)] = value;
}
void Args::AddArgOverrides(const Scope::KeyValueMap& overrides) {
@@ -131,7 +131,7 @@
std::lock_guard<std::mutex> lock(lock_);
Scope::KeyValueMap::const_iterator found =
- all_overrides_.find(base::StringPiece(name));
+ all_overrides_.find(std::string_view(name));
if (found == all_overrides_.end())
return nullptr;
return &found->second;
@@ -240,7 +240,7 @@
// Some assignments in args.gn had no effect. Show an error for the first
// unused assignment.
- base::StringPiece name = unused_overrides.begin()->first;
+ std::string_view name = unused_overrides.begin()->first;
const Value& value = unused_overrides.begin()->second;
std::string err_help(
@@ -250,12 +250,12 @@
"To view all possible args, run \"gn args --list <out_dir>\"");
// Use all declare_args for a spelling suggestion.
- std::vector<base::StringPiece> candidates;
+ std::vector<std::string_view> candidates;
for (const auto& map_pair : declared_arguments_per_toolchain_) {
for (const auto& declared_arg : map_pair.second)
candidates.push_back(declared_arg.first);
}
- base::StringPiece suggestion = SpellcheckString(name, candidates);
+ std::string_view suggestion = SpellcheckString(name, candidates);
if (!suggestion.empty())
err_help = "Did you mean \"" + suggestion + "\"?\n\n" + err_help;
diff --git a/tools/gn/args.h b/tools/gn/args.h
index 4a4bc7c..3921e23 100644
--- a/tools/gn/args.h
+++ b/tools/gn/args.h
@@ -37,7 +37,7 @@
bool has_override; // True indicates override_value is valid.
Value override_value; // From .gn or the current build's "gn args".
};
- using ValueWithOverrideMap = std::map<base::StringPiece, ValueWithOverride>;
+ using ValueWithOverrideMap = std::map<std::string_view, ValueWithOverride>;
Args();
Args(const Args& other);
diff --git a/tools/gn/bundle_data.cc b/tools/gn/bundle_data.cc
index 9de0e8c..60500c6 100644
--- a/tools/gn/bundle_data.cc
+++ b/tools/gn/bundle_data.cc
@@ -16,14 +16,14 @@
namespace {
// Return directory of |path| without the trailing directory separator.
-base::StringPiece FindDirNoTrailingSeparator(base::StringPiece path) {
- base::StringPiece::size_type pos = path.find_last_of("/\\");
- if (pos == base::StringPiece::npos)
- return base::StringPiece();
- return base::StringPiece(path.data(), pos);
+std::string_view FindDirNoTrailingSeparator(std::string_view path) {
+ std::string_view::size_type pos = path.find_last_of("/\\");
+ if (pos == std::string_view::npos)
+ return std::string_view();
+ return std::string_view(path.data(), pos);
}
-bool IsSourceFileFromAssetsCatalog(base::StringPiece source,
+bool IsSourceFileFromAssetsCatalog(std::string_view source,
SourceFile* asset_catalog) {
// Check whether |source| matches one of the following pattern:
// .*\.xcassets/Contents.json
@@ -31,7 +31,7 @@
// .*\.xcassets/[^/]*\.imageset/[^/]*
// .*\.xcassets/[^/]*\.launchimage/[^/]*
bool is_file_from_asset_catalog = false;
- base::StringPiece dir = FindDirNoTrailingSeparator(source);
+ std::string_view dir = FindDirNoTrailingSeparator(source);
if (base::EndsWith(source, "/Contents.json", base::CompareCase::SENSITIVE) &&
base::EndsWith(dir, ".xcassets", base::CompareCase::SENSITIVE)) {
is_file_from_asset_catalog = true;
diff --git a/tools/gn/c_include_iterator.cc b/tools/gn/c_include_iterator.cc
index 540d118..077609f 100644
--- a/tools/gn/c_include_iterator.cc
+++ b/tools/gn/c_include_iterator.cc
@@ -21,7 +21,7 @@
// Returns a new string piece referencing the same buffer as the argument, but
// with leading space trimmed. This only checks for space and tab characters
// since we're dealing with lines in C source files.
-base::StringPiece TrimLeadingWhitespace(const base::StringPiece& str) {
+std::string_view TrimLeadingWhitespace(const std::string_view& str) {
size_t new_begin = 0;
while (new_begin < str.size() &&
(str[new_begin] == ' ' || str[new_begin] == '\t'))
@@ -40,7 +40,7 @@
//
// We assume the line has leading whitespace trimmed. We also assume that empty
// lines have already been filtered out.
-bool ShouldCountTowardNonIncludeLines(const base::StringPiece& line) {
+bool ShouldCountTowardNonIncludeLines(const std::string_view& line) {
if (base::StartsWith(line, "//", base::CompareCase::SENSITIVE))
return false; // Don't count comments.
if (base::StartsWith(line, "/*", base::CompareCase::SENSITIVE) ||
@@ -59,15 +59,15 @@
//
// The 1-based character number on the line that the include was found at
// will be filled into *begin_char.
-IncludeType ExtractInclude(const base::StringPiece& line,
- base::StringPiece* path,
+IncludeType ExtractInclude(const std::string_view& line,
+ std::string_view* path,
int* begin_char) {
static const char kInclude[] = "include";
static const size_t kIncludeLen = arraysize(kInclude) - 1; // No null.
static const char kImport[] = "import";
static const size_t kImportLen = arraysize(kImport) - 1; // No null.
- base::StringPiece trimmed = TrimLeadingWhitespace(line);
+ std::string_view trimmed = TrimLeadingWhitespace(line);
if (trimmed.empty())
return INCLUDE_NONE;
@@ -76,11 +76,11 @@
trimmed = TrimLeadingWhitespace(trimmed.substr(1));
- base::StringPiece contents;
- if (base::StartsWith(trimmed, base::StringPiece(kInclude, kIncludeLen),
+ std::string_view contents;
+ if (base::StartsWith(trimmed, std::string_view(kInclude, kIncludeLen),
base::CompareCase::SENSITIVE))
contents = TrimLeadingWhitespace(trimmed.substr(kIncludeLen));
- else if (base::StartsWith(trimmed, base::StringPiece(kImport, kImportLen),
+ else if (base::StartsWith(trimmed, std::string_view(kImport, kImportLen),
base::CompareCase::SENSITIVE))
contents = TrimLeadingWhitespace(trimmed.substr(kImportLen));
@@ -101,7 +101,7 @@
// Count everything to next "/> as the contents.
size_t terminator_index = contents.find(terminating_char, 1);
- if (terminator_index == base::StringPiece::npos)
+ if (terminator_index == std::string_view::npos)
return INCLUDE_NONE;
*path = contents.substr(1, terminator_index - 1);
@@ -111,8 +111,8 @@
}
// Returns true if this line has a "nogncheck" comment associated with it.
-bool HasNoCheckAnnotation(const base::StringPiece& line) {
- return line.find("nogncheck") != base::StringPiece::npos;
+bool HasNoCheckAnnotation(const std::string_view& line) {
+ return line.find("nogncheck") != std::string_view::npos;
}
} // namespace
@@ -124,13 +124,13 @@
CIncludeIterator::~CIncludeIterator() = default;
-bool CIncludeIterator::GetNextIncludeString(base::StringPiece* out,
+bool CIncludeIterator::GetNextIncludeString(std::string_view* out,
LocationRange* location) {
- base::StringPiece line;
+ std::string_view line;
int cur_line_number = 0;
while (lines_since_last_include_ <= kMaxNonIncludeLines &&
GetNextLine(&line, &cur_line_number)) {
- base::StringPiece include_contents;
+ std::string_view include_contents;
int begin_char;
IncludeType type = ExtractInclude(line, &include_contents, &begin_char);
if (type == INCLUDE_USER && !HasNoCheckAnnotation(line)) {
@@ -153,7 +153,7 @@
return false;
}
-bool CIncludeIterator::GetNextLine(base::StringPiece* line, int* line_number) {
+bool CIncludeIterator::GetNextLine(std::string_view* line, int* line_number) {
if (offset_ == file_.size())
return false;
diff --git a/tools/gn/c_include_iterator.h b/tools/gn/c_include_iterator.h
index 86a0954..0c379e1 100644
--- a/tools/gn/c_include_iterator.h
+++ b/tools/gn/c_include_iterator.h
@@ -7,8 +7,9 @@
#include <stddef.h>
+#include <string_view>
+
#include "base/macros.h"
-#include "base/strings/string_piece.h"
class InputFile;
class LocationRange;
@@ -26,7 +27,7 @@
// Fills in the string with the contents of the next include, and the
// location with where it came from, and returns true, or returns false if
// there are no more includes.
- bool GetNextIncludeString(base::StringPiece* out, LocationRange* location);
+ bool GetNextIncludeString(std::string_view* out, LocationRange* location);
// Maximum numbef of non-includes we'll tolerate before giving up. This does
// not count comments or preprocessor.
@@ -35,12 +36,12 @@
private:
// Returns false on EOF, otherwise fills in the given line and the one-based
// line number into *line_number;
- bool GetNextLine(base::StringPiece* line, int* line_number);
+ bool GetNextLine(std::string_view* line, int* line_number);
const InputFile* input_file_;
// This just points into input_file_.contents() for convenience.
- base::StringPiece file_;
+ std::string_view file_;
// 0-based offset into the file.
size_t offset_ = 0;
diff --git a/tools/gn/c_include_iterator_unittest.cc b/tools/gn/c_include_iterator_unittest.cc
index aa1f99a..de9b14a 100644
--- a/tools/gn/c_include_iterator_unittest.cc
+++ b/tools/gn/c_include_iterator_unittest.cc
@@ -44,7 +44,7 @@
CIncludeIterator iter(&file);
- base::StringPiece contents;
+ std::string_view contents;
LocationRange range;
EXPECT_TRUE(iter.GetNextIncludeString(&contents, &range));
EXPECT_EQ("foo/bar.h", contents);
@@ -77,7 +77,7 @@
InputFile file(SourceFile("//foo.cc"));
file.SetContents(buffer);
- base::StringPiece contents;
+ std::string_view contents;
LocationRange range;
CIncludeIterator iter(&file);
@@ -99,7 +99,7 @@
InputFile file(SourceFile("//foo.cc"));
file.SetContents(buffer);
- base::StringPiece contents;
+ std::string_view contents;
LocationRange range;
CIncludeIterator iter(&file);
@@ -126,7 +126,7 @@
InputFile file(SourceFile("//foo.cc"));
file.SetContents(buffer);
- base::StringPiece contents;
+ std::string_view contents;
LocationRange range;
CIncludeIterator iter(&file);
@@ -152,7 +152,7 @@
InputFile file(SourceFile("//foo.cc"));
file.SetContents(buffer);
- base::StringPiece contents;
+ std::string_view contents;
LocationRange range;
CIncludeIterator iter(&file);
@@ -167,7 +167,7 @@
InputFile file(SourceFile("//foo.cc"));
file.SetContents(buffer);
- base::StringPiece contents;
+ std::string_view contents;
LocationRange range;
CIncludeIterator iter(&file);
diff --git a/tools/gn/command_args.cc b/tools/gn/command_args.cc
index 26b8bd6..41f9f5b 100644
--- a/tools/gn/command_args.cc
+++ b/tools/gn/command_args.cc
@@ -40,7 +40,7 @@
const char kSwitchOverridesOnly[] = "overrides-only";
const char kSwitchJson[] = "json";
-bool DoesLineBeginWithComment(const base::StringPiece& line) {
+bool DoesLineBeginWithComment(const std::string_view& line) {
// Skip whitespace.
size_t i = 0;
while (i < line.size() && base::IsAsciiWhitespace(line[i]))
@@ -67,7 +67,7 @@
// Assumes DoesLineBeginWithComment(), this strips the # character from the
// beginning and normalizes preceding whitespace.
-std::string StripHashFromLine(const base::StringPiece& line, bool pad) {
+std::string StripHashFromLine(const std::string_view& line, bool pad) {
// Replace the # sign and everything before it with 3 spaces, so that a
// normal comment that has a space after the # will be indented 4 spaces
// (which makes our formatting come out nicely). If the comment is indented
@@ -104,8 +104,8 @@
line_off -= 2; // Back up to end of previous line.
size_t previous_line_offset = BackUpToLineBegin(data, line_off);
- base::StringPiece line(&data[previous_line_offset],
- line_off - previous_line_offset + 1);
+ std::string_view line(&data[previous_line_offset],
+ line_off - previous_line_offset + 1);
if (!DoesLineBeginWithComment(line))
break;
@@ -120,7 +120,7 @@
// is a bit different.
//
// The default value also contains the docstring.
-void PrintDefaultValueInfo(base::StringPiece name, const Value& value) {
+void PrintDefaultValueInfo(std::string_view name, const Value& value) {
OutputString(value.ToString(true) + "\n");
if (value.origin()) {
int line_no;
@@ -137,7 +137,7 @@
}
// Override value is null if there is no override.
-void PrintArgHelp(const base::StringPiece& name,
+void PrintArgHelp(const std::string_view& name,
const Args::ValueWithOverride& val) {
OutputString(std::string(name), DECORATION_YELLOW);
OutputString("\n");
@@ -163,7 +163,7 @@
}
void BuildArgJson(base::Value& dict,
- const base::StringPiece& name,
+ const std::string_view& name,
const Args::ValueWithOverride& arg,
bool short_only) {
assert(dict.is_dict());
diff --git a/tools/gn/command_clean.cc b/tools/gn/command_clean.cc
index 32aaf77..d2822fc 100644
--- a/tools/gn/command_clean.cc
+++ b/tools/gn/command_clean.cc
@@ -27,7 +27,7 @@
if (!base::ReadFileToString(build_ninja_file, &file_contents))
return std::string();
- std::vector<base::StringPiece> lines = base::SplitStringPiece(
+ std::vector<std::string_view> lines = base::SplitStringPiece(
file_contents, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
std::string result;
diff --git a/tools/gn/command_format.cc b/tools/gn/command_format.cc
index a8604a5..15689ad 100644
--- a/tools/gn/command_format.cc
+++ b/tools/gn/command_format.cc
@@ -127,7 +127,7 @@
};
// Add to output.
- void Print(base::StringPiece str);
+ void Print(std::string_view str);
// Add the current margin (as spaces) to the output.
void PrintMargin();
@@ -238,7 +238,7 @@
std::vector<IndentState> stack_;
// Gives the precedence for operators in a BinaryOpNode.
- std::map<base::StringPiece, Precedence> precedence_;
+ std::map<std::string_view, Precedence> precedence_;
DISALLOW_COPY_AND_ASSIGN(Printer);
};
@@ -264,7 +264,7 @@
Printer::~Printer() = default;
-void Printer::Print(base::StringPiece str) {
+void Printer::Print(std::string_view str) {
output_.append(str);
}
@@ -323,7 +323,7 @@
// This is somewhat arbitrary, but we include the 'deps'- and 'sources'-like
// things, but not flags things.
if (binop->op().value() == "=" && ident && list) {
- const base::StringPiece lhs = ident->value().value();
+ const std::string_view lhs = ident->value().value();
if (lhs == "data" || lhs == "datadeps" || lhs == "data_deps" ||
lhs == "deps" || lhs == "inputs" || lhs == "outputs" ||
lhs == "public" || lhs == "public_deps" || lhs == "sources") {
@@ -347,7 +347,7 @@
if ((binop->op().value() == "=" || binop->op().value() == "+=" ||
binop->op().value() == "-=") &&
ident && list) {
- const base::StringPiece lhs = ident->value().value();
+ const std::string_view lhs = ident->value().value();
if (lhs == "public" || lhs == "sources")
const_cast<ListNode*>(list)->SortAsStringsList();
else if (lhs == "deps" || lhs == "public_deps")
@@ -389,14 +389,14 @@
const std::unique_ptr<PARSENODE>& b) const {
const auto& a_args = a->AsFunctionCall()->args()->contents();
const auto& b_args = b->AsFunctionCall()->args()->contents();
- base::StringPiece a_name;
- base::StringPiece b_name;
+ std::string_view a_name;
+ std::string_view b_name;
if (!a_args.empty())
a_name = a_args[0]->AsLiteral()->value().value();
if (!b_args.empty())
b_name = b_args[0]->AsLiteral()->value().value();
- auto is_absolute = [](base::StringPiece import) {
+ auto is_absolute = [](std::string_view import) {
return import.size() >= 3 && import[0] == '"' && import[1] == '/' &&
import[2] == '/';
};
diff --git a/tools/gn/command_help.cc b/tools/gn/command_help.cc
index 987f506..86ca088 100644
--- a/tools/gn/command_help.cc
+++ b/tools/gn/command_help.cc
@@ -215,7 +215,7 @@
bool PrintHelpOnSwitch(const std::string& what) {
const switches::SwitchInfoMap& all = switches::GetSwitches();
switches::SwitchInfoMap::const_iterator found =
- all.find(base::StringPiece(what));
+ all.find(std::string_view(what));
if (found == all.end())
return false;
PrintLongHelp(found->second.long_help);
@@ -280,7 +280,7 @@
what = args[0];
}
- std::vector<base::StringPiece> all_help_topics;
+ std::vector<std::string_view> all_help_topics;
// Special-case ambiguous topics.
if (what == "args") {
@@ -361,7 +361,7 @@
// No help on this.
Err(Location(), "No help on \"" + what + "\".").PrintToStdout();
- base::StringPiece suggestion = SpellcheckString(what, all_help_topics);
+ std::string_view suggestion = SpellcheckString(what, all_help_topics);
if (suggestion.empty()) {
OutputString("Run `gn help` for a list of available topics.\n",
DECORATION_NONE);
diff --git a/tools/gn/commands.h b/tools/gn/commands.h
index d6b6728..f57f740 100644
--- a/tools/gn/commands.h
+++ b/tools/gn/commands.h
@@ -8,9 +8,9 @@
#include <map>
#include <set>
#include <string>
+#include <string_view>
#include <vector>
-#include "base/strings/string_piece.h"
#include "base/values.h"
#include "tools/gn/target.h"
#include "tools/gn/unique_vector.h"
@@ -102,7 +102,7 @@
CommandRunner runner;
};
-typedef std::map<base::StringPiece, CommandInfo> CommandInfoMap;
+typedef std::map<std::string_view, CommandInfo> CommandInfoMap;
const CommandInfoMap& GetCommands();
@@ -145,7 +145,8 @@
bool CheckPublicHeaders(const BuildSettings* build_settings,
const std::vector<const Target*>& all_targets,
const std::vector<const Target*>& to_check,
- bool force_check, bool check_generated);
+ bool force_check,
+ bool check_generated);
// Filters the given list of targets by the given pattern list.
void FilterTargetsByPatterns(const std::vector<const Target*>& input,
diff --git a/tools/gn/create_bundle_target_generator.cc b/tools/gn/create_bundle_target_generator.cc
index 2c5a3af..be60f50 100644
--- a/tools/gn/create_bundle_target_generator.cc
+++ b/tools/gn/create_bundle_target_generator.cc
@@ -73,7 +73,7 @@
bool CreateBundleTargetGenerator::FillBundleDir(
const SourceDir& bundle_root_dir,
- const base::StringPiece& name,
+ const std::string_view& name,
SourceDir* bundle_dir) {
// All bundle_foo_dir properties are optional. They are only required if they
// are used in an expansion. The check is performed there.
diff --git a/tools/gn/create_bundle_target_generator.h b/tools/gn/create_bundle_target_generator.h
index a7f1edc..63b85fa 100644
--- a/tools/gn/create_bundle_target_generator.h
+++ b/tools/gn/create_bundle_target_generator.h
@@ -24,7 +24,7 @@
private:
bool FillBundleDir(const SourceDir& bundle_root_dir,
- const base::StringPiece& name,
+ const std::string_view& name,
SourceDir* bundle_dir);
bool FillXcodeExtraAttributes();
diff --git a/tools/gn/err.cc b/tools/gn/err.cc
index 4f60964..4d3cbce 100644
--- a/tools/gn/err.cc
+++ b/tools/gn/err.cc
@@ -17,7 +17,7 @@
namespace {
-std::string GetNthLine(const base::StringPiece& data, int n) {
+std::string GetNthLine(const std::string_view& data, int n) {
size_t line_off = Tokenizer::ByteOffsetOfNthLine(data, n);
size_t end = line_off + 1;
while (end < data.size() && !Tokenizer::IsNewline(data, end))
diff --git a/tools/gn/escape.cc b/tools/gn/escape.cc
index d5e33c0..ef4dcfa 100644
--- a/tools/gn/escape.cc
+++ b/tools/gn/escape.cc
@@ -62,7 +62,7 @@
return ch == '$' || ch == ' ' || ch == ':';
}
-size_t EscapeStringToString_Ninja(const base::StringPiece& str,
+size_t EscapeStringToString_Ninja(const std::string_view& str,
const EscapeOptions& options,
char* dest,
bool* needed_quoting) {
@@ -75,7 +75,7 @@
return i;
}
-size_t EscapeStringToString_Depfile(const base::StringPiece& str,
+size_t EscapeStringToString_Depfile(const std::string_view& str,
const EscapeOptions& options,
char* dest,
bool* needed_quoting) {
@@ -93,7 +93,7 @@
return i;
}
-size_t EscapeStringToString_NinjaPreformatted(const base::StringPiece& str,
+size_t EscapeStringToString_NinjaPreformatted(const std::string_view& str,
char* dest) {
// Only Ninja-escape $.
size_t i = 0;
@@ -113,7 +113,7 @@
// See:
// http://blogs.msdn.com/b/twistylittlepassagesallalike/archive/2011/04/23/everyone-quotes-arguments-the-wrong-way.aspx
// http://blogs.msdn.com/b/oldnewthing/archive/2010/09/17/10063629.aspx
-size_t EscapeStringToString_WindowsNinjaFork(const base::StringPiece& str,
+size_t EscapeStringToString_WindowsNinjaFork(const std::string_view& str,
const EscapeOptions& options,
char* dest,
bool* needed_quoting) {
@@ -165,7 +165,7 @@
return i;
}
-size_t EscapeStringToString_PosixNinjaFork(const base::StringPiece& str,
+size_t EscapeStringToString_PosixNinjaFork(const std::string_view& str,
const EscapeOptions& options,
char* dest,
bool* needed_quoting) {
@@ -196,7 +196,7 @@
}
// Escapes |str| into |dest| and returns the number of characters written.
-size_t EscapeStringToString(const base::StringPiece& str,
+size_t EscapeStringToString(const std::string_view& str,
const EscapeOptions& options,
char* dest,
bool* needed_quoting) {
@@ -237,7 +237,7 @@
} // namespace
-std::string EscapeString(const base::StringPiece& str,
+std::string EscapeString(const std::string_view& str,
const EscapeOptions& options,
bool* needed_quoting) {
StackOrHeapBuffer dest(str.size() * kMaxEscapedCharsPerChar);
@@ -246,7 +246,7 @@
}
void EscapeStringToStream(std::ostream& out,
- const base::StringPiece& str,
+ const std::string_view& str,
const EscapeOptions& options) {
StackOrHeapBuffer dest(str.size() * kMaxEscapedCharsPerChar);
out.write(dest, EscapeStringToString(str, options, dest, nullptr));
diff --git a/tools/gn/escape.h b/tools/gn/escape.h
index af5f8b8..36a9c5c 100644
--- a/tools/gn/escape.h
+++ b/tools/gn/escape.h
@@ -6,8 +6,7 @@
#define TOOLS_GN_ESCAPE_H_
#include <iosfwd>
-
-#include "base/strings/string_piece.h"
+#include <string_view>
enum EscapingMode {
// No escaping.
@@ -64,14 +63,14 @@
// (if inhibit_quoting was set) quoted will be written to it. This value should
// be initialized to false by the caller and will be written to only if it's
// true (the common use-case is for chaining calls).
-std::string EscapeString(const base::StringPiece& str,
+std::string EscapeString(const std::string_view& str,
const EscapeOptions& options,
bool* needed_quoting);
// Same as EscapeString but writes the results to the given stream, saving a
// copy.
void EscapeStringToStream(std::ostream& out,
- const base::StringPiece& str,
+ const std::string_view& str,
const EscapeOptions& options);
#endif // TOOLS_GN_ESCAPE_H_
diff --git a/tools/gn/exec_process.cc b/tools/gn/exec_process.cc
index 2496405..e266d90 100644
--- a/tools/gn/exec_process.cc
+++ b/tools/gn/exec_process.cc
@@ -42,7 +42,7 @@
std_err, exit_code);
}
-bool ExecProcess(const base::string16& cmdline_str,
+bool ExecProcess(const std::u16string& cmdline_str,
const base::FilePath& startup_dir,
std::string* std_out,
std::string* std_err,
@@ -94,7 +94,7 @@
start_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
start_info.dwFlags |= STARTF_USESTDHANDLES;
- base::string16 cmdline_writable = cmdline_str;
+ std::u16string cmdline_writable = cmdline_str;
// Create the child process.
PROCESS_INFORMATION temp_process_info = {};
diff --git a/tools/gn/exec_process.h b/tools/gn/exec_process.h
index 278d539..91ee876 100644
--- a/tools/gn/exec_process.h
+++ b/tools/gn/exec_process.h
@@ -7,7 +7,6 @@
#include <string>
-#include "base/strings/string16.h"
#include "util/build_config.h"
namespace base {
@@ -24,7 +23,7 @@
int* exit_code);
#if defined(OS_WIN)
-bool ExecProcess(const base::string16& cmdline_str,
+bool ExecProcess(const std::u16string& cmdline_str,
const base::FilePath& startup_dir,
std::string* std_out,
std::string* std_err,
diff --git a/tools/gn/filesystem_utils.cc b/tools/gn/filesystem_utils.cc
index ea4dfb8..43efcc3 100644
--- a/tools/gn/filesystem_utils.cc
+++ b/tools/gn/filesystem_utils.cc
@@ -81,8 +81,8 @@
// Attempts to do a case and slash-insensitive comparison of two 8-bit Windows
// paths.
-bool AreAbsoluteWindowsPathsEqual(const base::StringPiece& a,
- const base::StringPiece& b) {
+bool AreAbsoluteWindowsPathsEqual(const std::string_view& a,
+ const std::string_view& b) {
if (a.size() != b.size())
return false;
@@ -95,7 +95,7 @@
return true;
}
-bool DoesBeginWindowsDriveLetter(const base::StringPiece& path) {
+bool DoesBeginWindowsDriveLetter(const std::string_view& path) {
if (path.size() < 3)
return false;
@@ -200,7 +200,7 @@
}
}
-size_t AbsPathLenWithNoTrailingSlash(const base::StringPiece& path) {
+size_t AbsPathLenWithNoTrailingSlash(const std::string_view& path) {
size_t len = path.size();
#if defined(OS_WIN)
size_t min_len = 3;
@@ -222,7 +222,7 @@
#endif
}
-base::FilePath UTF8ToFilePath(const base::StringPiece& sp) {
+base::FilePath UTF8ToFilePath(const std::string_view& sp) {
#if defined(OS_WIN)
return base::FilePath(base::UTF8ToUTF16(sp));
#else
@@ -240,12 +240,12 @@
return std::string::npos;
}
-base::StringPiece FindExtension(const std::string* path) {
+std::string_view FindExtension(const std::string* path) {
size_t extension_offset = FindExtensionOffset(*path);
if (extension_offset == std::string::npos)
- return base::StringPiece();
- return base::StringPiece(&path->data()[extension_offset],
- path->size() - extension_offset);
+ return std::string_view();
+ return std::string_view(&path->data()[extension_offset],
+ path->size() - extension_offset);
}
size_t FindFilenameOffset(const std::string& path) {
@@ -256,17 +256,17 @@
return 0; // No filename found means everything was the filename.
}
-base::StringPiece FindFilename(const std::string* path) {
+std::string_view FindFilename(const std::string* path) {
size_t filename_offset = FindFilenameOffset(*path);
if (filename_offset == 0)
- return base::StringPiece(*path); // Everything is the file name.
- return base::StringPiece(&(*path).data()[filename_offset],
- path->size() - filename_offset);
+ return std::string_view(*path); // Everything is the file name.
+ return std::string_view(&(*path).data()[filename_offset],
+ path->size() - filename_offset);
}
-base::StringPiece FindFilenameNoExtension(const std::string* path) {
+std::string_view FindFilenameNoExtension(const std::string* path) {
if (path->empty())
- return base::StringPiece();
+ return std::string_view();
size_t filename_offset = FindFilenameOffset(*path);
size_t extension_offset = FindExtensionOffset(*path);
@@ -276,7 +276,7 @@
else
name_len = extension_offset - filename_offset - 1;
- return base::StringPiece(&(*path).data()[filename_offset], name_len);
+ return std::string_view(&(*path).data()[filename_offset], name_len);
}
void RemoveFilename(std::string* path) {
@@ -287,18 +287,18 @@
return !s.empty() && IsSlash(s[s.size() - 1]);
}
-base::StringPiece FindDir(const std::string* path) {
+std::string_view FindDir(const std::string* path) {
size_t filename_offset = FindFilenameOffset(*path);
if (filename_offset == 0u)
- return base::StringPiece();
- return base::StringPiece(path->data(), filename_offset);
+ return std::string_view();
+ return std::string_view(path->data(), filename_offset);
}
-base::StringPiece FindLastDirComponent(const SourceDir& dir) {
+std::string_view FindLastDirComponent(const SourceDir& dir) {
const std::string& dir_string = dir.value();
if (dir_string.empty())
- return base::StringPiece();
+ return std::string_view();
int cur = static_cast<int>(dir_string.size()) - 1;
DCHECK(dir_string[cur] == '/');
int end = cur;
@@ -306,9 +306,9 @@
for (; cur >= 0; cur--) {
if (dir_string[cur] == '/')
- return base::StringPiece(&dir_string[cur + 1], end - cur - 1);
+ return std::string_view(&dir_string[cur + 1], end - cur - 1);
}
- return base::StringPiece(&dir_string[0], end);
+ return std::string_view(&dir_string[0], end);
}
bool IsStringInOutputDir(const SourceDir& output_dir, const std::string& str) {
@@ -334,7 +334,7 @@
return false;
}
-bool IsPathAbsolute(const base::StringPiece& path) {
+bool IsPathAbsolute(const std::string_view& path) {
if (path.empty())
return false;
@@ -355,12 +355,12 @@
return true;
}
-bool IsPathSourceAbsolute(const base::StringPiece& path) {
+bool IsPathSourceAbsolute(const std::string_view& path) {
return (path.size() >= 2 && path[0] == '/' && path[1] == '/');
}
-bool MakeAbsolutePathRelativeIfPossible(const base::StringPiece& source_root,
- const base::StringPiece& path,
+bool MakeAbsolutePathRelativeIfPossible(const std::string_view& source_root,
+ const std::string_view& path,
std::string* dest) {
DCHECK(IsPathAbsolute(source_root));
DCHECK(IsPathAbsolute(path));
@@ -504,7 +504,7 @@
return base::FilePath(base::JoinString(relative_components, separator));
}
-void NormalizePath(std::string* path, const base::StringPiece& source_root) {
+void NormalizePath(std::string* path, const std::string_view& source_root) {
char* pathbuf = path->empty() ? nullptr : &(*path)[0];
// top_index is the first character we can modify in the path. Anything
@@ -702,7 +702,7 @@
std::string RebasePath(const std::string& input,
const SourceDir& dest_dir,
- const base::StringPiece& source_root) {
+ const std::string_view& source_root) {
std::string ret;
DCHECK(source_root.empty() ||
!base::EndsWith(source_root, "/", base::CompareCase::SENSITIVE));
@@ -784,7 +784,7 @@
std::string ResolveRelative(const StringType& input,
const std::string& value,
bool as_file,
- const base::StringPiece& source_root) {
+ const std::string_view& source_root) {
std::string result;
if (input.size() >= 2 && input[0] == '/' && input[1] == '/') {
@@ -846,15 +846,15 @@
}
// Explicit template instantiation
-template std::string ResolveRelative(const base::StringPiece& input,
+template std::string ResolveRelative(const std::string_view& input,
const std::string& value,
bool as_file,
- const base::StringPiece& source_root);
+ const std::string_view& source_root);
template std::string ResolveRelative(const std::string& input,
const std::string& value,
bool as_file,
- const base::StringPiece& source_root);
+ const std::string_view& source_root);
std::string DirectoryWithNoLastSlash(const SourceDir& dir) {
std::string ret;
diff --git a/tools/gn/filesystem_utils.h b/tools/gn/filesystem_utils.h
index 220c4f8..f25e702 100644
--- a/tools/gn/filesystem_utils.h
+++ b/tools/gn/filesystem_utils.h
@@ -8,9 +8,9 @@
#include <stddef.h>
#include <string>
+#include <string_view>
#include "base/files/file_path.h"
-#include "base/strings/string_piece.h"
#include "tools/gn/settings.h"
#include "tools/gn/target.h"
@@ -20,7 +20,7 @@
inline std::string FilePathToUTF8(const base::FilePath& path) {
return FilePathToUTF8(path.value());
}
-base::FilePath UTF8ToFilePath(const base::StringPiece& sp);
+base::FilePath UTF8ToFilePath(const std::string_view& sp);
// Extensions -----------------------------------------------------------------
@@ -31,7 +31,7 @@
// Returns a string piece pointing into the input string identifying the
// extension. Note that the input pointer must outlive the output.
-base::StringPiece FindExtension(const std::string* path);
+std::string_view FindExtension(const std::string* path);
// Filename parts -------------------------------------------------------------
@@ -43,10 +43,10 @@
// Returns a string piece pointing into the input string identifying the
// file name (following the last slash, including the extension). Note that the
// input pointer must outlive the output.
-base::StringPiece FindFilename(const std::string* path);
+std::string_view FindFilename(const std::string* path);
// Like FindFilename but does not include the extension.
-base::StringPiece FindFilenameNoExtension(const std::string* path);
+std::string_view FindFilenameNoExtension(const std::string* path);
// Removes everything after the last slash. The last slash, if any, will be
// preserved.
@@ -67,11 +67,11 @@
// Returns a string piece pointing into the input string identifying the
// directory name of the given path, including the last slash. Note that the
// input pointer must outlive the output.
-base::StringPiece FindDir(const std::string* path);
+std::string_view FindDir(const std::string* path);
// Returns the substring identifying the last component of the dir, or the
// empty substring if none. For example "//foo/bar/" -> "bar".
-base::StringPiece FindLastDirComponent(const SourceDir& dir);
+std::string_view FindLastDirComponent(const SourceDir& dir);
// Returns true if the given string is in the given output dir. This is pretty
// stupid and doesn't handle "." and "..", etc., it is designed for a sanity
@@ -96,12 +96,12 @@
// Returns true if the input string is absolute. Double-slashes at the
// beginning are treated as source-relative paths. On Windows, this handles
// paths of both the native format: "C:/foo" and ours "/C:/foo"
-bool IsPathAbsolute(const base::StringPiece& path);
+bool IsPathAbsolute(const std::string_view& path);
// Returns true if the input string is source-absolute. Source-absolute
// paths begin with two forward slashes and resolve as if they are
// relative to the source root.
-bool IsPathSourceAbsolute(const base::StringPiece& path);
+bool IsPathSourceAbsolute(const std::string_view& path);
// Given an absolute path, checks to see if is it is inside the source root.
// If it is, fills a source-absolute path into the given output and returns
@@ -112,8 +112,8 @@
// ("/C:/"). The source root can end with a slash or not.
//
// Note that this does not attempt to normalize slashes in the output.
-bool MakeAbsolutePathRelativeIfPossible(const base::StringPiece& source_root,
- const base::StringPiece& path,
+bool MakeAbsolutePathRelativeIfPossible(const std::string_view& source_root,
+ const std::string_view& path,
std::string* dest);
// Given two absolute paths |base| and |target|, returns a relative path to
@@ -134,7 +134,7 @@
// a leading slash. Otherwise, |path| will retain its relativity. |source_root|
// must not end with a slash.
void NormalizePath(std::string* path,
- const base::StringPiece& source_root = base::StringPiece());
+ const std::string_view& source_root = std::string_view());
// Converts slashes to backslashes for Windows. Keeps the string unchanged
// for other systems.
@@ -150,7 +150,7 @@
std::string RebasePath(
const std::string& input,
const SourceDir& dest_dir,
- const base::StringPiece& source_root = base::StringPiece());
+ const std::string_view& source_root = std::string_view());
// Resolves a file or dir name (parameter input) relative to
// value directory. Will return an empty SourceDir/File on error
@@ -169,7 +169,7 @@
std::string ResolveRelative(const StringType& input,
const std::string& value,
bool as_file,
- const base::StringPiece& source_root);
+ const std::string_view& source_root);
// Resolves source file or directory relative to some given source root. Returns
// an empty file path on error.
diff --git a/tools/gn/filesystem_utils_unittest.cc b/tools/gn/filesystem_utils_unittest.cc
index 2f8df44..da1d4b1 100644
--- a/tools/gn/filesystem_utils_unittest.cc
+++ b/tools/gn/filesystem_utils_unittest.cc
@@ -424,7 +424,7 @@
}
TEST(FilesystemUtils, RebasePath) {
- base::StringPiece source_root("/source/root");
+ std::string_view source_root("/source/root");
// Degenerate case.
EXPECT_EQ(".", RebasePath("//", SourceDir("//"), source_root));
@@ -468,84 +468,84 @@
// Check when only |input| is system-absolute
EXPECT_EQ("foo", RebasePath("/source/root/foo", SourceDir("//"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
EXPECT_EQ("foo/", RebasePath("/source/root/foo/", SourceDir("//"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
EXPECT_EQ("../../builddir/Out/Debug",
RebasePath("/builddir/Out/Debug", SourceDir("//"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
EXPECT_EQ("../../../builddir/Out/Debug",
RebasePath("/builddir/Out/Debug", SourceDir("//"),
- base::StringPiece("/source/root/foo")));
+ std::string_view("/source/root/foo")));
EXPECT_EQ("../../../builddir/Out/Debug/",
RebasePath("/builddir/Out/Debug/", SourceDir("//"),
- base::StringPiece("/source/root/foo")));
+ std::string_view("/source/root/foo")));
EXPECT_EQ("../../path/to/foo", RebasePath("/path/to/foo", SourceDir("//"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
EXPECT_EQ("../../../path/to/foo",
RebasePath("/path/to/foo", SourceDir("//a"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
EXPECT_EQ("../../../../path/to/foo",
RebasePath("/path/to/foo", SourceDir("//a/b"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
// Check when only |dest_dir| is system-absolute.
EXPECT_EQ(".", RebasePath("//", SourceDir("/source/root"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
EXPECT_EQ("foo", RebasePath("//foo", SourceDir("/source/root"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
EXPECT_EQ("../foo", RebasePath("//foo", SourceDir("/source/root/bar"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
EXPECT_EQ("../../../source/root/foo",
RebasePath("//foo", SourceDir("/other/source/root"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
EXPECT_EQ("../../../../source/root/foo",
RebasePath("//foo", SourceDir("/other/source/root/bar"),
- base::StringPiece("/source/root")));
+ std::string_view("/source/root")));
// Check when |input| and |dest_dir| are both system-absolute. Also,
// in this case |source_root| is never used so set it to a dummy
// value.
EXPECT_EQ("foo", RebasePath("/source/root/foo", SourceDir("/source/root"),
- base::StringPiece("/x/y/z")));
+ std::string_view("/x/y/z")));
EXPECT_EQ("foo/", RebasePath("/source/root/foo/", SourceDir("/source/root"),
- base::StringPiece("/x/y/z")));
+ std::string_view("/x/y/z")));
EXPECT_EQ("../../builddir/Out/Debug",
RebasePath("/builddir/Out/Debug", SourceDir("/source/root"),
- base::StringPiece("/x/y/z")));
+ std::string_view("/x/y/z")));
EXPECT_EQ("../../../builddir/Out/Debug",
RebasePath("/builddir/Out/Debug", SourceDir("/source/root/foo"),
- base::StringPiece("/source/root/foo")));
+ std::string_view("/source/root/foo")));
EXPECT_EQ("../../../builddir/Out/Debug/",
RebasePath("/builddir/Out/Debug/", SourceDir("/source/root/foo"),
- base::StringPiece("/source/root/foo")));
+ std::string_view("/source/root/foo")));
EXPECT_EQ("../../path/to/foo",
RebasePath("/path/to/foo", SourceDir("/source/root"),
- base::StringPiece("/x/y/z")));
+ std::string_view("/x/y/z")));
EXPECT_EQ("../../../path/to/foo",
RebasePath("/path/to/foo", SourceDir("/source/root/a"),
- base::StringPiece("/x/y/z")));
+ std::string_view("/x/y/z")));
EXPECT_EQ("../../../../path/to/foo",
RebasePath("/path/to/foo", SourceDir("/source/root/a/b"),
- base::StringPiece("/x/y/z")));
+ std::string_view("/x/y/z")));
#if defined(OS_WIN)
// Test corrections while rebasing Windows-style absolute paths.
EXPECT_EQ("../../../../path/to/foo",
RebasePath("C:/path/to/foo", SourceDir("//a/b"),
- base::StringPiece("/C:/source/root")));
+ std::string_view("/C:/source/root")));
EXPECT_EQ("../../../../path/to/foo",
RebasePath("/C:/path/to/foo", SourceDir("//a/b"),
- base::StringPiece("C:/source/root")));
+ std::string_view("C:/source/root")));
EXPECT_EQ("../../../../path/to/foo",
RebasePath("/C:/path/to/foo", SourceDir("//a/b"),
- base::StringPiece("/c:/source/root")));
+ std::string_view("/c:/source/root")));
EXPECT_EQ("../../../../path/to/foo",
RebasePath("/c:/path/to/foo", SourceDir("//a/b"),
- base::StringPiece("c:/source/root")));
+ std::string_view("c:/source/root")));
EXPECT_EQ("../../../../path/to/foo",
RebasePath("/c:/path/to/foo", SourceDir("//a/b"),
- base::StringPiece("C:/source/root")));
+ std::string_view("C:/source/root")));
#endif
}
diff --git a/tools/gn/function_foreach.cc b/tools/gn/function_foreach.cc
index 24ffaab..ec9070f 100644
--- a/tools/gn/function_foreach.cc
+++ b/tools/gn/function_foreach.cc
@@ -62,7 +62,7 @@
Err(args_vector[0].get(), "Expected an identifier for the loop var.");
return Value();
}
- base::StringPiece loop_var(identifier->value().value());
+ std::string_view loop_var(identifier->value().value());
// Extract the list to iterate over. Always copy in case the code changes
// the list variable inside the loop.
diff --git a/tools/gn/function_forward_variables_from.cc b/tools/gn/function_forward_variables_from.cc
index 875af91..0366381 100644
--- a/tools/gn/function_forward_variables_from.cc
+++ b/tools/gn/function_forward_variables_from.cc
@@ -43,9 +43,10 @@
if (value) {
// Use the storage key for the original value rather than the string in
// "cur" because "cur" is a temporary that will be deleted, and Scopes
- // expect a persistent StringPiece (it won't copy). Not doing this will
- // lead the scope's key to point to invalid memory after this returns.
- base::StringPiece storage_key = source->GetStorageKey(cur.string_value());
+ // expect a persistent std::string_view (it won't copy). Not doing this
+ // will lead the scope's key to point to invalid memory after this
+ // returns.
+ std::string_view storage_key = source->GetStorageKey(cur.string_value());
if (storage_key.empty()) {
// Programmatic value, don't allow copying.
*err =
diff --git a/tools/gn/function_get_path_info.cc b/tools/gn/function_get_path_info.cc
index b392490..6e87a57 100644
--- a/tools/gn/function_get_path_info.cc
+++ b/tools/gn/function_get_path_info.cc
@@ -77,7 +77,7 @@
return std::string(FindExtension(&input_string));
}
case WHAT_DIR: {
- base::StringPiece dir_incl_slash = FindDir(&input_string);
+ std::string_view dir_incl_slash = FindDir(&input_string);
if (dir_incl_slash.empty())
return std::string(".");
// Trim slash since this function doesn't return trailing slashes. The
diff --git a/tools/gn/functions.cc b/tools/gn/functions.cc
index c0a64ac..74b48bc 100644
--- a/tools/gn/functions.cc
+++ b/tools/gn/functions.cc
@@ -135,7 +135,7 @@
// Set the target name variable to the current target, and mark it used
// because we don't want to issue an error if the script ignores it.
- const base::StringPiece target_name(variables::kTargetName);
+ const std::string_view target_name(variables::kTargetName);
block_scope->SetValue(target_name, Value(function, args[0].string_value()),
function);
block_scope->MarkUsed(target_name);
diff --git a/tools/gn/functions.h b/tools/gn/functions.h
index 9dc2cdc..4119571 100644
--- a/tools/gn/functions.h
+++ b/tools/gn/functions.h
@@ -7,10 +7,9 @@
#include <map>
#include <string>
+#include <string_view>
#include <vector>
-#include "base/strings/string_piece.h"
-
class Err;
class BlockNode;
class FunctionCallNode;
@@ -433,7 +432,7 @@
bool is_target;
};
-typedef std::map<base::StringPiece, FunctionInfo> FunctionInfoMap;
+typedef std::map<std::string_view, FunctionInfo> FunctionInfoMap;
// Returns the mapping of all built-in functions.
const FunctionInfoMap& GetFunctions();
diff --git a/tools/gn/generated_file_target_generator.cc b/tools/gn/generated_file_target_generator.cc
index 023e5d4..35e0db4 100644
--- a/tools/gn/generated_file_target_generator.cc
+++ b/tools/gn/generated_file_target_generator.cc
@@ -68,7 +68,7 @@
}
bool GeneratedFileTargetGenerator::IsMetadataCollectionTarget(
- const base::StringPiece& variable,
+ const std::string_view& variable,
const ParseNode* origin) {
if (contents_defined_) {
*err_ =
diff --git a/tools/gn/generated_file_target_generator.h b/tools/gn/generated_file_target_generator.h
index 206555f..cdcea14 100644
--- a/tools/gn/generated_file_target_generator.h
+++ b/tools/gn/generated_file_target_generator.h
@@ -35,7 +35,7 @@
// it is okay to set metadata collection variables on this target.
//
// Should be called before FillContents().
- bool IsMetadataCollectionTarget(const base::StringPiece& variable,
+ bool IsMetadataCollectionTarget(const std::string_view& variable,
const ParseNode* origin);
bool contents_defined_ = false;
diff --git a/tools/gn/header_checker.cc b/tools/gn/header_checker.cc
index 14784b7..f4af9d8 100644
--- a/tools/gn/header_checker.cc
+++ b/tools/gn/header_checker.cc
@@ -244,7 +244,7 @@
}
SourceFile HeaderChecker::SourceFileForInclude(
- const base::StringPiece& relative_file_path,
+ const std::string_view& relative_file_path,
const std::vector<SourceDir>& include_dirs,
const InputFile& source_file,
const LocationRange& range,
@@ -308,7 +308,7 @@
size_t error_count_before = errors->size();
CIncludeIterator iter(&input_file);
- base::StringPiece current_include;
+ std::string_view current_include;
LocationRange range;
std::set<std::pair<const Target*, const Target*>> no_dependency_cache;
diff --git a/tools/gn/header_checker.h b/tools/gn/header_checker.h
index 3932001..8e73c19 100644
--- a/tools/gn/header_checker.h
+++ b/tools/gn/header_checker.h
@@ -9,13 +9,13 @@
#include <map>
#include <mutex>
#include <set>
+#include <string_view>
#include <vector>
#include "base/atomic_ref_count.h"
#include "base/gtest_prod_util.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
-#include "base/strings/string_piece.h"
#include "tools/gn/err.h"
#include "tools/gn/source_dir.h"
@@ -112,7 +112,7 @@
bool IsFileInOuputDir(const SourceFile& file) const;
// Resolves the contents of an include to a SourceFile.
- SourceFile SourceFileForInclude(const base::StringPiece& relative_file_path,
+ SourceFile SourceFileForInclude(const std::string_view& relative_file_path,
const std::vector<SourceDir>& include_dirs,
const InputFile& source_file,
const LocationRange& range,
diff --git a/tools/gn/input_conversion.cc b/tools/gn/input_conversion.cc
index 270d437..d2acb71 100644
--- a/tools/gn/input_conversion.cc
+++ b/tools/gn/input_conversion.cc
@@ -107,7 +107,7 @@
return ret;
}
-bool IsIdentifier(const base::StringPiece& buffer) {
+bool IsIdentifier(const std::string_view& buffer) {
DCHECK(buffer.size() > 0);
if (!Tokenizer::IsIdentifierFirstChar(buffer[0]))
return false;
@@ -146,14 +146,13 @@
}
// Search for the key in the input file. We know it's present because
// it was parsed by the JSON reader, but we need its location to
- // construct a StringPiece that can be used as key in the Scope.
+ // construct a std::string_view that can be used as key in the Scope.
size_t off = input_file->contents().find("\"" + it.first + "\"");
if (off == std::string::npos) {
*err = Err(origin, "Invalid encoding \"" + it.first + "\".");
return Value();
}
- base::StringPiece key(&input_file->contents()[off + 1],
- it.first.size());
+ std::string_view key(&input_file->contents()[off + 1], it.first.size());
scope->SetValue(key, std::move(parsed_value), origin);
}
return Value(origin, std::move(scope));
diff --git a/tools/gn/label.cc b/tools/gn/label.cc
index 22b6f81..e5a1148 100644
--- a/tools/gn/label.cc
+++ b/tools/gn/label.cc
@@ -29,7 +29,7 @@
// used. The value is used only for generating error messages.
bool ComputeBuildLocationFromDep(const Value& input_value,
const SourceDir& current_dir,
- const base::StringPiece& input,
+ const std::string_view& input,
SourceDir* result,
Err* err) {
// No rule, use the current location.
@@ -48,7 +48,7 @@
// error messages.
bool ComputeTargetNameFromDep(const Value& input_value,
const SourceDir& computed_location,
- const base::StringPiece& input,
+ const std::string_view& input,
std::string* result,
Err* err) {
if (!input.empty()) {
@@ -88,13 +88,14 @@
bool Resolve(const SourceDir& current_dir,
const Label& current_toolchain,
const Value& original_value,
- const base::StringPiece& input,
+ const std::string_view& input,
SourceDir* out_dir,
std::string* out_name,
SourceDir* out_toolchain_dir,
std::string* out_toolchain_name,
Err* err) {
- // To workaround the problem that StringPiece operator[] doesn't return a ref.
+ // To workaround the problem that std::string_view operator[] doesn't return a
+ // ref.
const char* input_str = input.data();
size_t offset = 0;
#if defined(OS_WIN)
@@ -110,19 +111,19 @@
}
#endif
size_t path_separator = input.find_first_of(":(", offset);
- base::StringPiece location_piece;
- base::StringPiece name_piece;
- base::StringPiece toolchain_piece;
+ std::string_view location_piece;
+ std::string_view name_piece;
+ std::string_view toolchain_piece;
if (path_separator == std::string::npos) {
location_piece = input;
// Leave name & toolchain piece null.
} else {
- location_piece = base::StringPiece(&input_str[0], path_separator);
+ location_piece = std::string_view(&input_str[0], path_separator);
size_t toolchain_separator = input.find('(', path_separator);
if (toolchain_separator == std::string::npos) {
- name_piece = base::StringPiece(&input_str[path_separator + 1],
- input.size() - path_separator - 1);
+ name_piece = std::string_view(&input_str[path_separator + 1],
+ input.size() - path_separator - 1);
// Leave location piece null.
} else if (!out_toolchain_dir) {
// Toolchain specified but not allows in this context.
@@ -135,9 +136,8 @@
// Name piece is everything between the two separators. Note that the
// separators may be the same (e.g. "//foo(bar)" which means empty name.
if (toolchain_separator > path_separator) {
- name_piece =
- base::StringPiece(&input_str[path_separator + 1],
- toolchain_separator - path_separator - 1);
+ name_piece = std::string_view(&input_str[path_separator + 1],
+ toolchain_separator - path_separator - 1);
}
// Toolchain name should end in a ) and this should be the end of the
@@ -151,8 +151,8 @@
// Subtract off the two parens to just get the toolchain name.
toolchain_piece =
- base::StringPiece(&input_str[toolchain_separator + 1],
- input.size() - toolchain_separator - 2);
+ std::string_view(&input_str[toolchain_separator + 1],
+ input.size() - toolchain_separator - 2);
}
}
@@ -251,15 +251,15 @@
)*";
Label::Label(const SourceDir& dir,
- const base::StringPiece& name,
+ const std::string_view& name,
const SourceDir& toolchain_dir,
- const base::StringPiece& toolchain_name)
+ const std::string_view& toolchain_name)
: dir_(dir), toolchain_dir_(toolchain_dir) {
name_.assign(name.data(), name.size());
toolchain_name_.assign(toolchain_name.data(), toolchain_name.size());
}
-Label::Label(const SourceDir& dir, const base::StringPiece& name) : dir_(dir) {
+Label::Label(const SourceDir& dir, const std::string_view& name) : dir_(dir) {
name_.assign(name.data(), name.size());
}
diff --git a/tools/gn/label.h b/tools/gn/label.h
index 44f6e40..9fd245f 100644
--- a/tools/gn/label.h
+++ b/tools/gn/label.h
@@ -24,12 +24,12 @@
// Makes a label given an already-separated out path and name.
// See also Resolve().
Label(const SourceDir& dir,
- const base::StringPiece& name,
+ const std::string_view& name,
const SourceDir& toolchain_dir,
- const base::StringPiece& toolchain_name);
+ const std::string_view& toolchain_name);
// Makes a label with an empty toolchain.
- Label(const SourceDir& dir, const base::StringPiece& name);
+ Label(const SourceDir& dir, const std::string_view& name);
// Resolves a string from a build file that may be relative to the
// current directory into a fully qualified label. On failure returns an
diff --git a/tools/gn/label_pattern.cc b/tools/gn/label_pattern.cc
index bed4d86..b69cfe4 100644
--- a/tools/gn/label_pattern.cc
+++ b/tools/gn/label_pattern.cc
@@ -53,7 +53,7 @@
LabelPattern::LabelPattern(Type type,
const SourceDir& dir,
- const base::StringPiece& name,
+ const std::string_view& name,
const Label& toolchain_label)
: toolchain_(toolchain_label), type_(type), dir_(dir), name_(name) {}
@@ -68,7 +68,7 @@
if (!value.VerifyTypeIs(Value::STRING, err))
return LabelPattern();
- base::StringPiece str(value.string_value());
+ std::string_view str(value.string_value());
if (str.empty()) {
*err = Err(value, "Label pattern must not be empty.");
return LabelPattern();
@@ -120,8 +120,8 @@
}
// Extract path and name.
- base::StringPiece path;
- base::StringPiece name;
+ std::string_view path;
+ std::string_view name;
size_t offset = 0;
#if defined(OS_WIN)
if (IsPathAbsolute(str)) {
@@ -136,7 +136,7 @@
#endif
size_t colon = str.find(':', offset);
if (colon == std::string::npos) {
- path = base::StringPiece(str);
+ path = std::string_view(str);
} else {
path = str.substr(0, colon);
name = str.substr(colon + 1);
@@ -173,7 +173,7 @@
// Resolve the part of the path that's not the wildcard.
if (!path.empty()) {
// The non-wildcard stuff better not have a wildcard.
- if (path.find('*') != base::StringPiece::npos) {
+ if (path.find('*') != std::string_view::npos) {
*err = Err(value, "Label patterns only support wildcard suffixes.",
"The pattern contained a '*' that wasn't at the end.");
return LabelPattern();
@@ -207,7 +207,7 @@
}
// When we're doing wildcard matching, the name is always empty.
- return LabelPattern(type, dir, base::StringPiece(), toolchain_label);
+ return LabelPattern(type, dir, std::string_view(), toolchain_label);
}
bool LabelPattern::HasWildcard(const std::string& str) {
diff --git a/tools/gn/label_pattern.h b/tools/gn/label_pattern.h
index 231fd6d..675d328 100644
--- a/tools/gn/label_pattern.h
+++ b/tools/gn/label_pattern.h
@@ -5,7 +5,8 @@
#ifndef TOOLS_GN_LABEL_PATTERN_H_
#define TOOLS_GN_LABEL_PATTERN_H_
-#include "base/strings/string_piece.h"
+#include <string_view>
+
#include "tools/gn/label.h"
#include "tools/gn/source_dir.h"
@@ -29,7 +30,7 @@
LabelPattern();
LabelPattern(Type type,
const SourceDir& dir,
- const base::StringPiece& name,
+ const std::string_view& name,
const Label& toolchain_label);
LabelPattern(const LabelPattern& other);
~LabelPattern();
diff --git a/tools/gn/lib_file.cc b/tools/gn/lib_file.cc
index 81e54fb..50295ac 100644
--- a/tools/gn/lib_file.cc
+++ b/tools/gn/lib_file.cc
@@ -8,7 +8,7 @@
LibFile::LibFile(const SourceFile& source_file) : source_file_(source_file) {}
-LibFile::LibFile(const base::StringPiece& lib_name)
+LibFile::LibFile(const std::string_view& lib_name)
: name_(lib_name.data(), lib_name.size()) {
DCHECK(!lib_name.empty());
}
diff --git a/tools/gn/lib_file.h b/tools/gn/lib_file.h
index 58621eb..b971ad6 100644
--- a/tools/gn/lib_file.h
+++ b/tools/gn/lib_file.h
@@ -9,8 +9,8 @@
#include <algorithm>
#include <string>
+#include <string_view>
-#include "base/strings/string_piece.h"
#include "tools/gn/source_file.h"
// Represents an entry in "libs" list. Can be either a path (a SourceFile) or
@@ -19,7 +19,7 @@
public:
LibFile() = default;
- explicit LibFile(const base::StringPiece& lib_name);
+ explicit LibFile(const std::string_view& lib_name);
explicit LibFile(const SourceFile& source_file);
bool is_source_file() const { return name_.empty(); }
diff --git a/tools/gn/metadata_unittest.cc b/tools/gn/metadata_unittest.cc
index 901e539..683e65f 100644
--- a/tools/gn/metadata_unittest.cc
+++ b/tools/gn/metadata_unittest.cc
@@ -17,8 +17,8 @@
b_expected.list_value().push_back(Value(nullptr, true));
Metadata::Contents contents;
- contents.insert(std::pair<base::StringPiece, Value>("a", a_expected));
- contents.insert(std::pair<base::StringPiece, Value>("b", b_expected));
+ contents.insert(std::pair<std::string_view, Value>("a", a_expected));
+ contents.insert(std::pair<std::string_view, Value>("b", b_expected));
metadata.set_contents(std::move(contents));
@@ -41,7 +41,7 @@
a_expected.list_value().push_back(Value(nullptr, "bar.h"));
metadata.contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
std::vector<std::string> data_keys;
data_keys.emplace_back("a");
@@ -75,7 +75,7 @@
a_expected.list_value().push_back(Value(nullptr, "foo/bar.h"));
metadata.contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
std::vector<std::string> data_keys;
data_keys.emplace_back("a");
@@ -117,7 +117,7 @@
inner_scope.SetScopeValue(std::move(scope));
a.list_value().push_back(inner_scope);
- metadata.contents().insert(std::pair<base::StringPiece, Value>("a", a));
+ metadata.contents().insert(std::pair<std::string_view, Value>("a", a));
std::vector<std::string> data_keys;
data_keys.emplace_back("a");
std::vector<std::string> walk_keys;
@@ -162,7 +162,7 @@
a_expected.list_value().push_back(Value(nullptr, "//target"));
metadata.contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
std::vector<std::string> data_keys;
std::vector<std::string> walk_keys;
@@ -213,7 +213,7 @@
a_expected.list_value().push_back(Value(nullptr, "//target"));
metadata.contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
std::vector<std::string> data_keys;
std::vector<std::string> walk_keys;
diff --git a/tools/gn/metadata_walk_unittest.cc b/tools/gn/metadata_walk_unittest.cc
index a18a07e..04f7cd1 100644
--- a/tools/gn/metadata_walk_unittest.cc
+++ b/tools/gn/metadata_walk_unittest.cc
@@ -17,12 +17,12 @@
Value a_expected(nullptr, Value::LIST);
a_expected.list_value().push_back(Value(nullptr, "foo"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
Value b_expected(nullptr, Value::LIST);
b_expected.list_value().push_back(Value(nullptr, true));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("b", b_expected));
+ std::pair<std::string_view, Value>("b", b_expected));
one.metadata().set_source_dir(SourceDir("/usr/home/files/"));
@@ -30,12 +30,12 @@
Value a_2_expected(nullptr, Value::LIST);
a_2_expected.list_value().push_back(Value(nullptr, "bar"));
two.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_2_expected));
+ std::pair<std::string_view, Value>("a", a_2_expected));
Value b_2_expected(nullptr, Value::LIST);
b_2_expected.list_value().push_back(Value(nullptr, false));
two.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("b", b_2_expected));
+ std::pair<std::string_view, Value>("b", b_2_expected));
two.metadata().set_source_dir(SourceDir("/usr/home/files/inner"));
@@ -75,18 +75,18 @@
Value a_expected(nullptr, Value::LIST);
a_expected.list_value().push_back(Value(nullptr, "foo"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
Value b_expected(nullptr, Value::LIST);
b_expected.list_value().push_back(Value(nullptr, true));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("b", b_expected));
+ std::pair<std::string_view, Value>("b", b_expected));
TestTarget two(setup, "//foo:two", Target::SOURCE_SET);
Value a_2_expected(nullptr, Value::LIST);
a_2_expected.list_value().push_back(Value(nullptr, "bar"));
two.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_2_expected));
+ std::pair<std::string_view, Value>("a", a_2_expected));
one.public_deps().push_back(LabelTargetPair(&two));
@@ -124,25 +124,25 @@
Value a_expected(nullptr, Value::LIST);
a_expected.list_value().push_back(Value(nullptr, "foo"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
Value walk_expected(nullptr, Value::LIST);
walk_expected.list_value().push_back(
Value(nullptr, "//foo:two(//toolchain:default)"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("walk", walk_expected));
+ std::pair<std::string_view, Value>("walk", walk_expected));
TestTarget two(setup, "//foo:two", Target::SOURCE_SET);
Value a_2_expected(nullptr, Value::LIST);
a_2_expected.list_value().push_back(Value(nullptr, "bar"));
two.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_2_expected));
+ std::pair<std::string_view, Value>("a", a_2_expected));
TestTarget three(setup, "//foo:three", Target::SOURCE_SET);
Value a_3_expected(nullptr, Value::LIST);
a_3_expected.list_value().push_back(Value(nullptr, "baz"));
three.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_3_expected));
+ std::pair<std::string_view, Value>("a", a_3_expected));
one.public_deps().push_back(LabelTargetPair(&two));
one.public_deps().push_back(LabelTargetPair(&three));
@@ -180,12 +180,12 @@
Value a_expected(nullptr, Value::LIST);
a_expected.list_value().push_back(Value(nullptr, "foo"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
Value walk_expected(nullptr, Value::LIST);
walk_expected.list_value().push_back(Value(nullptr, "//foo:missing"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("walk", walk_expected));
+ std::pair<std::string_view, Value>("walk", walk_expected));
UniqueVector<const Target*> targets;
targets.push_back(&one);
diff --git a/tools/gn/operators.cc b/tools/gn/operators.cc
index 24b17c0..ab77782 100644
--- a/tools/gn/operators.cc
+++ b/tools/gn/operators.cc
@@ -101,7 +101,7 @@
}
// Known to be an accessor.
- base::StringPiece base_str = dest_accessor->base().value();
+ std::string_view base_str = dest_accessor->base().value();
Value* base =
exec_scope->GetMutableValue(base_str, Scope::SEARCH_CURRENT, false);
if (!base) {
diff --git a/tools/gn/output_conversion_unittest.cc b/tools/gn/output_conversion_unittest.cc
index 2e4146d..ad6ea80 100644
--- a/tools/gn/output_conversion_unittest.cc
+++ b/tools/gn/output_conversion_unittest.cc
@@ -100,7 +100,7 @@
// Add some values to the scope.
Value value(nullptr, "hello");
new_scope->SetValue("v", value, nullptr);
- base::StringPiece private_var_name("_private");
+ std::string_view private_var_name("_private");
new_scope->SetValue(private_var_name, value, nullptr);
std::ostringstream result;
@@ -164,7 +164,7 @@
// Add some values to the scope.
Value value(nullptr, "hello");
new_scope->SetValue("v", value, nullptr);
- base::StringPiece private_var_name("_private");
+ std::string_view private_var_name("_private");
new_scope->SetValue(private_var_name, value, nullptr);
std::ostringstream result;
diff --git a/tools/gn/parse_tree.cc b/tools/gn/parse_tree.cc
index 337b3b2..b49fae7 100644
--- a/tools/gn/parse_tree.cc
+++ b/tools/gn/parse_tree.cc
@@ -36,7 +36,7 @@
DEPS_CATEGORY_OTHER,
};
-DepsCategory GetDepsCategory(base::StringPiece deps) {
+DepsCategory GetDepsCategory(std::string_view deps) {
if (deps.length() < 2 || deps[0] != '"' || deps[deps.size() - 1] != '"')
return DEPS_CATEGORY_OTHER;
@@ -49,19 +49,19 @@
return DEPS_CATEGORY_RELATIVE;
}
-std::tuple<base::StringPiece, base::StringPiece> SplitAtFirst(
- base::StringPiece str,
+std::tuple<std::string_view, std::string_view> SplitAtFirst(
+ std::string_view str,
char c) {
if (!base::StartsWith(str, "\"", base::CompareCase::SENSITIVE) ||
!base::EndsWith(str, "\"", base::CompareCase::SENSITIVE))
- return std::make_tuple(str, base::StringPiece());
+ return std::make_tuple(str, std::string_view());
str = str.substr(1, str.length() - 2);
size_t index_of_first = str.find(c);
return std::make_tuple(str.substr(0, index_of_first),
- index_of_first != base::StringPiece::npos
+ index_of_first != std::string_view::npos
? str.substr(index_of_first + 1)
- : base::StringPiece());
+ : std::string_view());
}
bool IsSortRangeSeparator(const ParseNode* node, const ParseNode* prev) {
@@ -74,7 +74,7 @@
static_cast<int>(node->comments()->before().size() + 1)));
}
-base::StringPiece GetStringRepresentation(const ParseNode* node) {
+std::string_view GetStringRepresentation(const ParseNode* node) {
DCHECK(node->AsLiteral() || node->AsIdentifier() || node->AsAccessor());
if (node->AsLiteral())
return node->AsLiteral()->value().value();
@@ -82,7 +82,7 @@
return node->AsIdentifier()->value().value();
else if (node->AsAccessor())
return node->AsAccessor()->base().value();
- return base::StringPiece();
+ return std::string_view();
}
} // namespace
@@ -148,7 +148,7 @@
}
base::Value ParseNode::CreateJSONNode(const char* type,
- const base::StringPiece& value) const {
+ const std::string_view& value) const {
base::Value dict(base::Value::Type::DICTIONARY);
dict.SetKey(kJsonNodeType, base::Value(type));
dict.SetKey(kJsonNodeValue, base::Value(value));
@@ -712,8 +712,8 @@
void ListNode::SortAsStringsList() {
// Sorts alphabetically.
SortList([](const ParseNode* a, const ParseNode* b) {
- base::StringPiece astr = GetStringRepresentation(a);
- base::StringPiece bstr = GetStringRepresentation(b);
+ std::string_view astr = GetStringRepresentation(a);
+ std::string_view bstr = GetStringRepresentation(b);
return astr < bstr;
});
}
@@ -722,8 +722,8 @@
// Sorts first relative targets, then absolute, each group is sorted
// alphabetically.
SortList([](const ParseNode* a, const ParseNode* b) {
- base::StringPiece astr = GetStringRepresentation(a);
- base::StringPiece bstr = GetStringRepresentation(b);
+ std::string_view astr = GetStringRepresentation(a);
+ std::string_view bstr = GetStringRepresentation(b);
return std::make_pair(GetDepsCategory(astr), SplitAtFirst(astr, ':')) <
std::make_pair(GetDepsCategory(bstr), SplitAtFirst(bstr, ':'));
});
@@ -807,7 +807,7 @@
case Token::FALSE_TOKEN:
return Value(this, false);
case Token::INTEGER: {
- base::StringPiece s = value_.value();
+ std::string_view s = value_.value();
if ((base::StartsWith(s, "0", base::CompareCase::SENSITIVE) &&
s.size() > 1) ||
base::StartsWith(s, "-0", base::CompareCase::SENSITIVE)) {
diff --git a/tools/gn/parse_tree.h b/tools/gn/parse_tree.h
index 6c61b72..82a5071 100644
--- a/tools/gn/parse_tree.h
+++ b/tools/gn/parse_tree.h
@@ -112,8 +112,8 @@
// Helper functions for GetJSONNode. Creates and fills a Value object with
// given type (and value).
base::Value CreateJSONNode(const char* type) const;
- base::Value CreateJSONNode(const char* type, const base::StringPiece& value)
- const;
+ base::Value CreateJSONNode(const char* type,
+ const std::string_view& value) const;
private:
// Helper function for CreateJSONNode.
diff --git a/tools/gn/parser.cc b/tools/gn/parser.cc
index ea498a4..b65a5de 100644
--- a/tools/gn/parser.cc
+++ b/tools/gn/parser.cc
@@ -290,7 +290,7 @@
};
Parser::Parser(const std::vector<Token>& tokens, Err* err)
- : invalid_token_(Location(), Token::INVALID, base::StringPiece()),
+ : invalid_token_(Location(), Token::INVALID, std::string_view()),
err_(err),
cur_(0) {
for (const auto& token : tokens) {
diff --git a/tools/gn/path_output.cc b/tools/gn/path_output.cc
index 0f57997..8da480a 100644
--- a/tools/gn/path_output.cc
+++ b/tools/gn/path_output.cc
@@ -11,7 +11,7 @@
#include "util/build_config.h"
PathOutput::PathOutput(const SourceDir& current_dir,
- const base::StringPiece& source_root,
+ const std::string_view& source_root,
EscapingMode escaping)
: current_dir_(current_dir) {
inverse_current_dir_ = RebasePath("//", current_dir, source_root);
@@ -65,7 +65,7 @@
} else {
// DIR_NO_LAST_SLASH mode, just trim the last char.
WritePathStr(out,
- base::StringPiece(dir.value().data(), dir.value().size() - 1));
+ std::string_view(dir.value().data(), dir.value().size() - 1));
}
}
@@ -104,8 +104,7 @@
file.value()[file.value().size() - 1] == '/') {
// Trim trailing slash.
EscapeStringToStream(
- out,
- base::StringPiece(file.value().data(), file.value().size() - 1),
+ out, std::string_view(file.value().data(), file.value().size() - 1),
options_);
} else {
// Doesn't end with a slash, write the whole thing.
@@ -122,7 +121,7 @@
}
void PathOutput::WriteSourceRelativeString(std::ostream& out,
- const base::StringPiece& str) const {
+ const std::string_view& str) const {
if (options_.mode == ESCAPE_NINJA_COMMAND) {
// Shell escaping needs an intermediate string since it may end up
// quoting the whole thing.
@@ -133,7 +132,7 @@
intermediate.append(str.data(), str.size());
EscapeStringToStream(
- out, base::StringPiece(intermediate.c_str(), intermediate.size()),
+ out, std::string_view(intermediate.c_str(), intermediate.size()),
options_);
} else {
// Ninja (and none) escaping can avoid the intermediate string and
@@ -144,11 +143,11 @@
}
void PathOutput::WritePathStr(std::ostream& out,
- const base::StringPiece& str) const {
+ const std::string_view& str) const {
DCHECK(str.size() > 0 && str[0] == '/');
if (str.substr(0, current_dir_.value().size()) ==
- base::StringPiece(current_dir_.value())) {
+ std::string_view(current_dir_.value())) {
// The current dir is a prefix of the output file, so we can strip the
// prefix and write out the result.
EscapeStringToStream(out, str.substr(current_dir_.value().size()),
diff --git a/tools/gn/path_output.h b/tools/gn/path_output.h
index 1d98a2c..21c4cc4 100644
--- a/tools/gn/path_output.h
+++ b/tools/gn/path_output.h
@@ -7,9 +7,9 @@
#include <iosfwd>
#include <string>
+#include <string_view>
#include "base/macros.h"
-#include "base/strings/string_piece.h"
#include "tools/gn/escape.h"
#include "tools/gn/source_dir.h"
#include "tools/gn/unique_vector.h"
@@ -35,7 +35,7 @@
};
PathOutput(const SourceDir& current_dir,
- const base::StringPiece& source_root,
+ const std::string_view& source_root,
EscapingMode escaping);
~PathOutput();
@@ -71,13 +71,13 @@
// Backend for WriteFile and WriteDir. This appends the given file or
// directory string to the file.
- void WritePathStr(std::ostream& out, const base::StringPiece& str) const;
+ void WritePathStr(std::ostream& out, const std::string_view& str) const;
private:
// Takes the given string and writes it out, appending to the inverse
// current dir. This assumes leading slashes have been trimmed.
void WriteSourceRelativeString(std::ostream& out,
- const base::StringPiece& str) const;
+ const std::string_view& str) const;
SourceDir current_dir_;
diff --git a/tools/gn/path_output_unittest.cc b/tools/gn/path_output_unittest.cc
index 8857fd9..190647a 100644
--- a/tools/gn/path_output_unittest.cc
+++ b/tools/gn/path_output_unittest.cc
@@ -14,7 +14,7 @@
TEST(PathOutput, Basic) {
SourceDir build_dir("//out/Debug/");
- base::StringPiece source_root("/source/root");
+ std::string_view source_root("/source/root");
PathOutput writer(build_dir, source_root, ESCAPE_NONE);
{
// Normal source-root path.
@@ -56,7 +56,7 @@
// Same as basic but the output dir is the root.
TEST(PathOutput, BasicInRoot) {
SourceDir build_dir("//");
- base::StringPiece source_root("/source/root");
+ std::string_view source_root("/source/root");
PathOutput writer(build_dir, source_root, ESCAPE_NONE);
{
// Normal source-root path.
@@ -74,7 +74,7 @@
TEST(PathOutput, NinjaEscaping) {
SourceDir build_dir("//out/Debug/");
- base::StringPiece source_root("/source/root");
+ std::string_view source_root("/source/root");
PathOutput writer(build_dir, source_root, ESCAPE_NINJA);
{
// Spaces and $ in filenames.
@@ -92,7 +92,7 @@
TEST(PathOutput, NinjaForkEscaping) {
SourceDir build_dir("//out/Debug/");
- base::StringPiece source_root("/source/root");
+ std::string_view source_root("/source/root");
PathOutput writer(build_dir, source_root, ESCAPE_NINJA_COMMAND);
// Spaces in filenames should get quoted on Windows.
@@ -145,7 +145,7 @@
TEST(PathOutput, InhibitQuoting) {
SourceDir build_dir("//out/Debug/");
- base::StringPiece source_root("/source/root");
+ std::string_view source_root("/source/root");
PathOutput writer(build_dir, source_root, ESCAPE_NINJA_COMMAND);
writer.set_inhibit_quoting(true);
@@ -169,7 +169,7 @@
TEST(PathOutput, WriteDir) {
{
SourceDir build_dir("//out/Debug/");
- base::StringPiece source_root("/source/root");
+ std::string_view source_root("/source/root");
PathOutput writer(build_dir, source_root, ESCAPE_NINJA);
{
std::ostringstream out;
@@ -259,7 +259,7 @@
}
{
// Empty build dir writer.
- base::StringPiece source_root("/source/root");
+ std::string_view source_root("/source/root");
PathOutput root_writer(SourceDir("//"), source_root, ESCAPE_NINJA);
{
std::ostringstream out;
diff --git a/tools/gn/scope.cc b/tools/gn/scope.cc
index 40d4a86..793f1a8 100644
--- a/tools/gn/scope.cc
+++ b/tools/gn/scope.cc
@@ -21,7 +21,7 @@
// Returns true if this variable name should be considered private. Private
// values start with an underscore, and are not imported from "gni" files
// when processing an import.
-bool IsPrivateVar(const base::StringPiece& name) {
+bool IsPrivateVar(const std::string_view& name) {
return name.empty() || name[0] == '_';
}
@@ -74,13 +74,13 @@
return !values_.empty();
}
-const Value* Scope::GetValue(const base::StringPiece& ident,
+const Value* Scope::GetValue(const std::string_view& ident,
bool counts_as_used) {
const Scope* found_in_scope = nullptr;
return GetValueWithScope(ident, counts_as_used, &found_in_scope);
}
-const Value* Scope::GetValueWithScope(const base::StringPiece& ident,
+const Value* Scope::GetValueWithScope(const std::string_view& ident,
bool counts_as_used,
const Scope** found_in_scope) {
// First check for programmatically-provided values.
@@ -110,7 +110,7 @@
return nullptr;
}
-Value* Scope::GetMutableValue(const base::StringPiece& ident,
+Value* Scope::GetMutableValue(const std::string_view& ident,
SearchNested search_mode,
bool counts_as_used) {
// Don't do programmatic values, which are not mutable.
@@ -129,7 +129,7 @@
return nullptr;
}
-base::StringPiece Scope::GetStorageKey(const base::StringPiece& ident) const {
+std::string_view Scope::GetStorageKey(const std::string_view& ident) const {
RecordMap::const_iterator found = values_.find(ident);
if (found != values_.end())
return found->first;
@@ -137,15 +137,15 @@
// Search in parent scope.
if (containing())
return containing()->GetStorageKey(ident);
- return base::StringPiece();
+ return std::string_view();
}
-const Value* Scope::GetValue(const base::StringPiece& ident) const {
+const Value* Scope::GetValue(const std::string_view& ident) const {
const Scope* found_in_scope = nullptr;
return GetValueWithScope(ident, &found_in_scope);
}
-const Value* Scope::GetValueWithScope(const base::StringPiece& ident,
+const Value* Scope::GetValueWithScope(const std::string_view& ident,
const Scope** found_in_scope) const {
RecordMap::const_iterator found = values_.find(ident);
if (found != values_.end()) {
@@ -157,7 +157,7 @@
return nullptr;
}
-Value* Scope::SetValue(const base::StringPiece& ident,
+Value* Scope::SetValue(const std::string_view& ident,
Value v,
const ParseNode* set_node) {
Record& r = values_[ident]; // Clears any existing value.
@@ -166,7 +166,7 @@
return &r.value;
}
-void Scope::RemoveIdentifier(const base::StringPiece& ident) {
+void Scope::RemoveIdentifier(const std::string_view& ident) {
RecordMap::iterator found = values_.find(ident);
if (found != values_.end())
values_.erase(found);
@@ -177,7 +177,7 @@
// currently backed by several different vendor-specific implementations and
// I'm not sure if all of them support mutating while iterating. Since this
// is not perf-critical, do the safe thing.
- std::vector<base::StringPiece> to_remove;
+ std::vector<std::string_view> to_remove;
for (const auto& cur : values_) {
if (IsPrivateVar(cur.first))
to_remove.push_back(cur.first);
@@ -203,7 +203,7 @@
return nullptr;
}
-void Scope::MarkUsed(const base::StringPiece& ident) {
+void Scope::MarkUsed(const std::string_view& ident) {
RecordMap::iterator found = values_.find(ident);
if (found == values_.end()) {
NOTREACHED();
@@ -227,7 +227,7 @@
}
}
-void Scope::MarkUnused(const base::StringPiece& ident) {
+void Scope::MarkUnused(const std::string_view& ident) {
RecordMap::iterator found = values_.find(ident);
if (found == values_.end()) {
NOTREACHED();
@@ -236,7 +236,7 @@
found->second.used = false;
}
-bool Scope::IsSetButUnused(const base::StringPiece& ident) const {
+bool Scope::IsSetButUnused(const std::string_view& ident) const {
RecordMap::const_iterator found = values_.find(ident);
if (found != values_.end()) {
if (!found->second.used) {
@@ -298,7 +298,7 @@
Err* err) const {
// Values.
for (const auto& pair : values_) {
- const base::StringPiece& current_name = pair.first;
+ const std::string_view& current_name = pair.first;
if (options.skip_private_vars && IsPrivateVar(current_name))
continue; // Skip this private var.
if (!options.excluded_values.empty() &&
diff --git a/tools/gn/scope.h b/tools/gn/scope.h
index f7d70ca..962f5c3 100644
--- a/tools/gn/scope.h
+++ b/tools/gn/scope.h
@@ -38,7 +38,7 @@
// variables. So you should use a non-const containing scope whenever possible.
class Scope {
public:
- using KeyValueMap = std::map<base::StringPiece, Value>;
+ using KeyValueMap = std::map<std::string_view, Value>;
// Holds an owning list of Items.
using ItemVector = std::vector<std::unique_ptr<Item>>;
@@ -59,7 +59,7 @@
// Returns a non-null value if the given value can be programmatically
// generated, or NULL if there is none.
virtual const Value* GetProgrammaticValue(
- const base::StringPiece& ident) = 0;
+ const std::string_view& ident) = 0;
protected:
Scope* scope_;
@@ -135,11 +135,11 @@
// found_in_scope is set to the scope that contains the definition of the
// ident. If the value was provided programmatically (like host_cpu),
// found_in_scope will be set to null.
- const Value* GetValue(const base::StringPiece& ident, bool counts_as_used);
- const Value* GetValue(const base::StringPiece& ident) const;
- const Value* GetValueWithScope(const base::StringPiece& ident,
+ const Value* GetValue(const std::string_view& ident, bool counts_as_used);
+ const Value* GetValue(const std::string_view& ident) const;
+ const Value* GetValueWithScope(const std::string_view& ident,
const Scope** found_in_scope) const;
- const Value* GetValueWithScope(const base::StringPiece& ident,
+ const Value* GetValueWithScope(const std::string_view& ident,
bool counts_as_used,
const Scope** found_in_scope);
@@ -165,28 +165,28 @@
// }
// The 6 should get set on the nested scope rather than modify the value
// in the outer one.
- Value* GetMutableValue(const base::StringPiece& ident,
+ Value* GetMutableValue(const std::string_view& ident,
SearchNested search_mode,
bool counts_as_used);
- // Returns the StringPiece used to identify the value. This string piece
+ // Returns the std::string_view used to identify the value. This string piece
// will have the same contents as "ident" passed in, but may point to a
- // different underlying buffer. This is useful because this StringPiece is
- // static and won't be deleted for the life of the program, so it can be used
- // as keys in places that may outlive a temporary. It will return an empty
- // string for programmatic and nonexistant values.
- base::StringPiece GetStorageKey(const base::StringPiece& ident) const;
+ // different underlying buffer. This is useful because this std::string_view
+ // is static and won't be deleted for the life of the program, so it can be
+ // used as keys in places that may outlive a temporary. It will return an
+ // empty string for programmatic and nonexistant values.
+ std::string_view GetStorageKey(const std::string_view& ident) const;
// The set_node indicates the statement that caused the set, for displaying
// errors later. Returns a pointer to the value in the current scope (a copy
// is made for storage).
- Value* SetValue(const base::StringPiece& ident,
+ Value* SetValue(const std::string_view& ident,
Value v,
const ParseNode* set_node);
// Removes the value with the given identifier if it exists on the current
// scope. This does not search recursive scopes. Does nothing if not found.
- void RemoveIdentifier(const base::StringPiece& ident);
+ void RemoveIdentifier(const std::string_view& ident);
// Removes from this scope all identifiers and templates that are considered
// private.
@@ -200,17 +200,17 @@
const Template* GetTemplate(const std::string& name) const;
// Marks the given identifier as (un)used in the current scope.
- void MarkUsed(const base::StringPiece& ident);
+ void MarkUsed(const std::string_view& ident);
void MarkAllUsed();
void MarkAllUsed(const std::set<std::string>& excluded_values);
- void MarkUnused(const base::StringPiece& ident);
+ void MarkUnused(const std::string_view& ident);
// Checks to see if the scope has a var set that hasn't been used. This is
// called before replacing the var with a different one. It does not check
// containing scopes.
//
// If the identifier is present but hasnn't been used, return true.
- bool IsSetButUnused(const base::StringPiece& ident) const;
+ bool IsSetButUnused(const std::string_view& ident) const;
// Checks the scope to see if any values were set but not used, and fills in
// the error and returns false if they were.
@@ -338,7 +338,7 @@
Value value;
};
- using RecordMap = std::unordered_map<base::StringPiece, Record>;
+ using RecordMap = std::unordered_map<std::string_view, Record>;
void AddProvider(ProgrammaticProvider* p);
void RemoveProvider(ProgrammaticProvider* p);
diff --git a/tools/gn/scope_per_file_provider.cc b/tools/gn/scope_per_file_provider.cc
index d7d11af..1adfa84 100644
--- a/tools/gn/scope_per_file_provider.cc
+++ b/tools/gn/scope_per_file_provider.cc
@@ -18,7 +18,7 @@
ScopePerFileProvider::~ScopePerFileProvider() = default;
const Value* ScopePerFileProvider::GetProgrammaticValue(
- const base::StringPiece& ident) {
+ const std::string_view& ident) {
if (ident == variables::kCurrentToolchain)
return GetCurrentToolchain();
if (ident == variables::kDefaultToolchain)
diff --git a/tools/gn/scope_per_file_provider.h b/tools/gn/scope_per_file_provider.h
index ac0d872..c7a76c0 100644
--- a/tools/gn/scope_per_file_provider.h
+++ b/tools/gn/scope_per_file_provider.h
@@ -21,7 +21,7 @@
~ScopePerFileProvider() override;
// ProgrammaticProvider implementation.
- const Value* GetProgrammaticValue(const base::StringPiece& ident) override;
+ const Value* GetProgrammaticValue(const std::string_view& ident) override;
private:
const Value* GetCurrentToolchain();
diff --git a/tools/gn/scope_unittest.cc b/tools/gn/scope_unittest.cc
index 681d6c8..f54c666 100644
--- a/tools/gn/scope_unittest.cc
+++ b/tools/gn/scope_unittest.cc
@@ -57,7 +57,7 @@
// Add some values to the scope.
Value old_value(&assignment, "hello");
setup.scope()->SetValue("v", old_value, &assignment);
- base::StringPiece private_var_name("_private");
+ std::string_view private_var_name("_private");
setup.scope()->SetValue(private_var_name, old_value, &assignment);
// Add some templates to the scope.
diff --git a/tools/gn/setup.cc b/tools/gn/setup.cc
index 1b2ad55..16e09fe 100644
--- a/tools/gn/setup.cc
+++ b/tools/gn/setup.cc
@@ -193,7 +193,7 @@
#if defined(OS_WIN)
-std::u16string SysMultiByteTo16(base::StringPiece mb) {
+std::u16string SysMultiByteTo16(std::string_view mb) {
if (mb.empty())
return std::u16string();
@@ -222,7 +222,7 @@
// quote the first argument in addition (to allow for spaces in the Python
// path, you need *another* set of quotes around that, likewise, we need
// two quotes at the end.
- base::string16 command = u"cmd.exe /c \"\"";
+ std::u16string command = u"cmd.exe /c \"\"";
command.append(bat_path.value());
command.append(u"\" -c \"import sys; print sys.executable\"\"");
@@ -245,11 +245,11 @@
return base::FilePath();
}
-const base::char16 kPythonExeName[] = u"python.exe";
-const base::char16 kPythonBatName[] = u"python.bat";
+const char16_t kPythonExeName[] = u"python.exe";
+const char16_t kPythonBatName[] = u"python.bat";
base::FilePath FindWindowsPython() {
- base::char16 current_directory[MAX_PATH];
+ char16_t current_directory[MAX_PATH];
::GetCurrentDirectory(MAX_PATH, reinterpret_cast<LPWSTR>(current_directory));
// First search for python.exe in the current directory.
@@ -259,12 +259,12 @@
return cur_dir_candidate_exe;
// Get the path.
- const base::char16 kPathEnvVarName[] = u"Path";
+ const char16_t kPathEnvVarName[] = u"Path";
DWORD path_length = ::GetEnvironmentVariable(
reinterpret_cast<LPCWSTR>(kPathEnvVarName), nullptr, 0);
if (path_length == 0)
return base::FilePath();
- std::unique_ptr<base::char16[]> full_path(new base::char16[path_length]);
+ std::unique_ptr<char16_t[]> full_path(new char16_t[path_length]);
DWORD actual_path_length = ::GetEnvironmentVariable(
reinterpret_cast<LPCWSTR>(kPathEnvVarName),
reinterpret_cast<LPWSTR>(full_path.get()), path_length);
@@ -272,7 +272,7 @@
// Search for python.exe in the path.
for (const auto& component : base::SplitStringPiece(
- base::StringPiece16(full_path.get(), path_length), u";",
+ std::u16string_view(full_path.get(), path_length), u";",
base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
base::FilePath candidate_exe =
base::FilePath(component).Append(kPythonExeName);
diff --git a/tools/gn/source_dir.cc b/tools/gn/source_dir.cc
index 7def4b2..e8c4ae9 100644
--- a/tools/gn/source_dir.cc
+++ b/tools/gn/source_dir.cc
@@ -77,7 +77,7 @@
const Value& blame_input_value,
const StringType& input_value,
Err* err,
- const base::StringPiece& source_root) const {
+ const std::string_view& source_root) const {
if (!ValidateResolveInput<StringType>(as_file, blame_input_value, input_value,
err)) {
return std::string();
@@ -88,7 +88,7 @@
SourceFile SourceDir::ResolveRelativeFile(
const Value& p,
Err* err,
- const base::StringPiece& source_root) const {
+ const std::string_view& source_root) const {
SourceFile ret;
if (!p.VerifyTypeIs(Value::STRING, err))
@@ -105,7 +105,7 @@
std::string SourceDir::ResolveRelativeAs(bool as_file,
const Value& v,
Err* err,
- const base::StringPiece& source_root,
+ const std::string_view& source_root,
const std::string* v_value) const {
if (!v.VerifyTypeIs(Value::STRING, err))
return std::string();
@@ -123,7 +123,7 @@
SourceDir SourceDir::ResolveRelativeDir(
const Value& v,
Err* err,
- const base::StringPiece& source_root) const {
+ const std::string_view& source_root) const {
if (!v.VerifyTypeIs(Value::STRING, err))
return SourceDir();
@@ -140,11 +140,11 @@
const Value& blame_input_value,
const std::string& input_value,
Err* err,
- const base::StringPiece& source_root) const;
+ const std::string_view& source_root) const;
template std::string SourceDir::ResolveRelativeAs(
bool as_file,
const Value& blame_input_value,
- const base::StringPiece& input_value,
+ const std::string_view& input_value,
Err* err,
- const base::StringPiece& source_root) const;
+ const std::string_view& source_root) const;
diff --git a/tools/gn/source_dir.h b/tools/gn/source_dir.h
index 8b6dcc9..ed4b1e3 100644
--- a/tools/gn/source_dir.h
+++ b/tools/gn/source_dir.h
@@ -9,10 +9,10 @@
#include <algorithm>
#include <string>
+#include <string_view>
#include "base/files/file_path.h"
#include "base/logging.h"
-#include "base/strings/string_piece.h"
class Err;
class SourceFile;
@@ -47,7 +47,7 @@
bool as_file,
const Value& v,
Err* err,
- const base::StringPiece& source_root = base::StringPiece(),
+ const std::string_view& source_root = std::string_view(),
const std::string* v_value = nullptr) const;
// Like ResolveRelativeAs above, but allows to produce result
@@ -58,13 +58,13 @@
const Value& blame_input_value,
const StringType& input_value,
Err* err,
- const base::StringPiece& source_root = base::StringPiece()) const;
+ const std::string_view& source_root = std::string_view()) const;
// Wrapper for ResolveRelativeAs.
SourceFile ResolveRelativeFile(
const Value& p,
Err* err,
- const base::StringPiece& source_root = base::StringPiece()) const;
+ const std::string_view& source_root = std::string_view()) const;
// Wrapper for ResolveRelativeAs.
template <typename StringType>
@@ -72,7 +72,7 @@
const Value& blame_input_value,
const StringType& input_value,
Err* err,
- const base::StringPiece& source_root = base::StringPiece()) const {
+ const std::string_view& source_root = std::string_view()) const {
SourceDir ret;
ret.value_ = ResolveRelativeAs<StringType>(false, blame_input_value,
input_value, err, source_root);
@@ -84,7 +84,7 @@
SourceDir ResolveRelativeDir(
const Value& v,
Err* err,
- const base::StringPiece& source_root = base::StringPiece()) const;
+ const std::string_view& source_root = std::string_view()) const;
// Resolves this source file relative to some given source root. Returns
// an empty file path on error.
@@ -110,19 +110,19 @@
//
// This function asserts that the directory is actually source-absolute. The
// return value points into our buffer.
- base::StringPiece SourceAbsoluteWithOneSlash() const {
+ std::string_view SourceAbsoluteWithOneSlash() const {
CHECK(is_source_absolute());
- return base::StringPiece(&value_[1], value_.size() - 1);
+ return std::string_view(&value_[1], value_.size() - 1);
}
// Returns a path that does not end with a slash.
//
// This function simply returns the reference to the value if the path is a
// root, e.g. "/" or "//".
- base::StringPiece SourceWithNoTrailingSlash() const {
+ std::string_view SourceWithNoTrailingSlash() const {
if (value_.size() > 2)
- return base::StringPiece(&value_[0], value_.size() - 1);
- return base::StringPiece(value_);
+ return std::string_view(&value_[0], value_.size() - 1);
+ return std::string_view(value_);
}
void SwapValue(std::string* v);
diff --git a/tools/gn/source_dir_unittest.cc b/tools/gn/source_dir_unittest.cc
index d5ada23..20c60b7 100644
--- a/tools/gn/source_dir_unittest.cc
+++ b/tools/gn/source_dir_unittest.cc
@@ -13,9 +13,9 @@
Err err;
SourceDir base("//base/");
#if defined(OS_WIN)
- base::StringPiece source_root("C:/source/root");
+ std::string_view source_root("C:/source/root");
#else
- base::StringPiece source_root("/source/root");
+ std::string_view source_root("/source/root");
#endif
// Empty input is an error.
@@ -116,9 +116,9 @@
Err err;
SourceDir base("//base/");
#if defined(OS_WIN)
- base::StringPiece source_root("C:/source/root");
+ std::string_view source_root("C:/source/root");
#else
- base::StringPiece source_root("/source/root");
+ std::string_view source_root("/source/root");
#endif
// Empty input is an error.
diff --git a/tools/gn/source_file.cc b/tools/gn/source_file.cc
index ce24207..d3ea1cc 100644
--- a/tools/gn/source_file.cc
+++ b/tools/gn/source_file.cc
@@ -22,7 +22,7 @@
}
SourceFile::Type GetSourceFileType(const std::string& file) {
- base::StringPiece extension = FindExtension(&file);
+ std::string_view extension = FindExtension(&file);
if (extension == "cc" || extension == "cpp" || extension == "cxx")
return SourceFile::SOURCE_CPP;
if (extension == "h" || extension == "hpp" || extension == "hxx" ||
diff --git a/tools/gn/source_file.h b/tools/gn/source_file.h
index 081cda6..392cdd4 100644
--- a/tools/gn/source_file.h
+++ b/tools/gn/source_file.h
@@ -9,10 +9,10 @@
#include <algorithm>
#include <string>
+#include <string_view>
#include "base/files/file_path.h"
#include "base/logging.h"
-#include "base/strings/string_piece.h"
class SourceDir;
@@ -78,9 +78,9 @@
//
// This function asserts that the file is actually source-absolute. The
// return value points into our buffer.
- base::StringPiece SourceAbsoluteWithOneSlash() const {
+ std::string_view SourceAbsoluteWithOneSlash() const {
CHECK(is_source_absolute());
- return base::StringPiece(&value_[1], value_.size() - 1);
+ return std::string_view(&value_[1], value_.size() - 1);
}
bool operator==(const SourceFile& other) const {
diff --git a/tools/gn/standard_out.cc b/tools/gn/standard_out.cc
index 3056418..003c8ee 100644
--- a/tools/gn/standard_out.cc
+++ b/tools/gn/standard_out.cc
@@ -6,11 +6,11 @@
#include <stddef.h>
+#include <string_view>
#include <vector>
#include "base/command_line.h"
#include "base/logging.h"
-#include "base/strings/string_piece.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "tools/gn/switches.h"
@@ -78,8 +78,8 @@
#endif // !defined(OS_WIN)
void OutputMarkdownDec(TextDecoration dec) {
-// The markdown rendering turns "dim" text to italics and any
-// other colored text to bold.
+ // The markdown rendering turns "dim" text to italics and any
+ // other colored text to bold.
#if defined(OS_WIN)
DWORD written = 0;
diff --git a/tools/gn/string_utils.cc b/tools/gn/string_utils.cc
index 89fc4b0..ab0aea8 100644
--- a/tools/gn/string_utils.cc
+++ b/tools/gn/string_utils.cc
@@ -117,7 +117,7 @@
size_t end_offset,
std::string* output,
Err* err) {
- base::StringPiece identifier(&input[begin_offset], end_offset - begin_offset);
+ std::string_view identifier(&input[begin_offset], end_offset - begin_offset);
const Value* value = scope->GetValue(identifier, true);
if (!value) {
// We assume the input points inside the token.
@@ -225,7 +225,7 @@
return false;
}
int value = 0;
- if (!base::HexStringToInt(base::StringPiece(&input[*i + 2], 2), &value)) {
+ if (!base::HexStringToInt(std::string_view(&input[*i + 2], 2), &value)) {
*err = ErrInsideStringToken(token, dollars_index, *i - dollars_index + 1,
"Could not convert hex value.");
return false;
@@ -287,8 +287,8 @@
return true;
}
-size_t EditDistance(const base::StringPiece& s1,
- const base::StringPiece& s2,
+size_t EditDistance(const std::string_view& s1,
+ const std::string_view& s2,
size_t max_edit_distance) {
// The algorithm implemented below is the "classic"
// dynamic-programming algorithm for computing the Levenshtein
@@ -329,14 +329,13 @@
return row[n];
}
-base::StringPiece SpellcheckString(
- const base::StringPiece& text,
- const std::vector<base::StringPiece>& words) {
+std::string_view SpellcheckString(const std::string_view& text,
+ const std::vector<std::string_view>& words) {
const size_t kMaxValidEditDistance = 3u;
size_t min_distance = kMaxValidEditDistance + 1u;
- base::StringPiece result;
- for (base::StringPiece word : words) {
+ std::string_view result;
+ for (std::string_view word : words) {
size_t distance = EditDistance(word, text, kMaxValidEditDistance);
if (distance < min_distance) {
min_distance = distance;
diff --git a/tools/gn/string_utils.h b/tools/gn/string_utils.h
index c77daca..3d4e056 100644
--- a/tools/gn/string_utils.h
+++ b/tools/gn/string_utils.h
@@ -6,16 +6,15 @@
#define TOOLS_GN_STRING_UTILS_H_
#include <string>
+#include <string_view>
#include <vector>
-#include "base/strings/string_piece.h"
-
class Err;
class Scope;
class Token;
class Value;
-inline std::string operator+(const std::string& a, const base::StringPiece& b) {
+inline std::string operator+(const std::string& a, const std::string_view& b) {
std::string ret;
ret.reserve(a.size() + b.size());
ret.assign(a);
@@ -23,7 +22,7 @@
return ret;
}
-inline std::string operator+(const base::StringPiece& a, const std::string& b) {
+inline std::string operator+(const std::string_view& a, const std::string& b) {
std::string ret;
ret.reserve(a.size() + b.size());
ret.assign(a.data(), a.size());
@@ -41,14 +40,14 @@
// Returns the minimum number of inserts, deleted, and replacements of
// characters needed to transform s1 to s2, or max_edit_distance + 1 if
// transforming s1 into s2 isn't possible in at most max_edit_distance steps.
-size_t EditDistance(const base::StringPiece& s1,
- const base::StringPiece& s2,
+size_t EditDistance(const std::string_view& s1,
+ const std::string_view& s2,
size_t max_edit_distance);
// Given a string |text| and a vector of correctly-spelled strings |words|,
// returns the first string in |words| closest to |text|, or an empty
-// StringPiece if none of the strings in |words| is close.
-base::StringPiece SpellcheckString(const base::StringPiece& text,
- const std::vector<base::StringPiece>& words);
+// std::string_view if none of the strings in |words| is close.
+std::string_view SpellcheckString(const std::string_view& text,
+ const std::vector<std::string_view>& words);
#endif // TOOLS_GN_STRING_UTILS_H_
diff --git a/tools/gn/string_utils_unittest.cc b/tools/gn/string_utils_unittest.cc
index bf10dd4..4c5cd81 100644
--- a/tools/gn/string_utils_unittest.cc
+++ b/tools/gn/string_utils_unittest.cc
@@ -144,7 +144,7 @@
}
TEST(StringUtils, SpellcheckString) {
- std::vector<base::StringPiece> words;
+ std::vector<std::string_view> words;
words.push_back("your");
words.push_back("bravado");
words.push_back("won\'t");
diff --git a/tools/gn/switches.h b/tools/gn/switches.h
index d1abb1f..9f0ddf0 100644
--- a/tools/gn/switches.h
+++ b/tools/gn/switches.h
@@ -6,8 +6,7 @@
#define TOOLS_GN_SWITCHES_H_
#include <map>
-
-#include "base/strings/string_piece.h"
+#include <string_view>
namespace switches {
@@ -19,7 +18,7 @@
const char* long_help;
};
-typedef std::map<base::StringPiece, SwitchInfo> SwitchInfoMap;
+typedef std::map<std::string_view, SwitchInfo> SwitchInfoMap;
// Returns the mapping of all global switches.
const SwitchInfoMap& GetSwitches();
diff --git a/tools/gn/target_unittest.cc b/tools/gn/target_unittest.cc
index f117846..24f4822 100644
--- a/tools/gn/target_unittest.cc
+++ b/tools/gn/target_unittest.cc
@@ -1108,12 +1108,12 @@
Value a_expected(nullptr, Value::LIST);
a_expected.list_value().push_back(Value(nullptr, "foo"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
Value b_expected(nullptr, Value::LIST);
b_expected.list_value().push_back(Value(nullptr, true));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("b", b_expected));
+ std::pair<std::string_view, Value>("b", b_expected));
one.metadata().set_source_dir(SourceDir("/usr/home/files/"));
@@ -1143,18 +1143,18 @@
Value a_expected(nullptr, Value::LIST);
a_expected.list_value().push_back(Value(nullptr, "foo"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
Value b_expected(nullptr, Value::LIST);
b_expected.list_value().push_back(Value(nullptr, true));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("b", b_expected));
+ std::pair<std::string_view, Value>("b", b_expected));
TestTarget two(setup, "//foo:two", Target::SOURCE_SET);
Value a_2_expected(nullptr, Value::LIST);
a_2_expected.list_value().push_back(Value(nullptr, "bar"));
two.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_2_expected));
+ std::pair<std::string_view, Value>("a", a_2_expected));
one.public_deps().push_back(LabelTargetPair(&two));
@@ -1185,25 +1185,25 @@
Value a_expected(nullptr, Value::LIST);
a_expected.list_value().push_back(Value(nullptr, "foo"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
Value walk_expected(nullptr, Value::LIST);
walk_expected.list_value().push_back(
Value(nullptr, "//foo:two(//toolchain:default)"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("walk", walk_expected));
+ std::pair<std::string_view, Value>("walk", walk_expected));
TestTarget two(setup, "//foo:two", Target::SOURCE_SET);
Value a_2_expected(nullptr, Value::LIST);
a_2_expected.list_value().push_back(Value(nullptr, "bar"));
two.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_2_expected));
+ std::pair<std::string_view, Value>("a", a_2_expected));
TestTarget three(setup, "//foo:three", Target::SOURCE_SET);
Value a_3_expected(nullptr, Value::LIST);
a_3_expected.list_value().push_back(Value(nullptr, "baz"));
three.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_3_expected));
+ std::pair<std::string_view, Value>("a", a_3_expected));
one.public_deps().push_back(LabelTargetPair(&two));
one.public_deps().push_back(LabelTargetPair(&three));
@@ -1234,12 +1234,12 @@
Value a_expected(nullptr, Value::LIST);
a_expected.list_value().push_back(Value(nullptr, "foo"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("a", a_expected));
+ std::pair<std::string_view, Value>("a", a_expected));
Value walk_expected(nullptr, Value::LIST);
walk_expected.list_value().push_back(Value(nullptr, "//foo:missing"));
one.metadata().contents().insert(
- std::pair<base::StringPiece, Value>("walk", walk_expected));
+ std::pair<std::string_view, Value>("walk", walk_expected));
std::vector<std::string> data_keys;
data_keys.push_back("a");
diff --git a/tools/gn/template.cc b/tools/gn/template.cc
index 2b40fb3..625cf5e 100644
--- a/tools/gn/template.cc
+++ b/tools/gn/template.cc
@@ -83,7 +83,7 @@
invoker_value->SetScopeValue(std::move(invocation_scope));
template_scope.set_source_dir(scope->GetSourceDir());
- const base::StringPiece target_name(variables::kTargetName);
+ const std::string_view target_name(variables::kTargetName);
template_scope.SetValue(
target_name, Value(invocation, args[0].string_value()), invocation);
diff --git a/tools/gn/token.cc b/tools/gn/token.cc
index 3c016fd..7951571 100644
--- a/tools/gn/token.cc
+++ b/tools/gn/token.cc
@@ -8,7 +8,7 @@
Token::Token() : type_(INVALID), value_() {}
-Token::Token(const Location& location, Type t, const base::StringPiece& v)
+Token::Token(const Location& location, Type t, const std::string_view& v)
: type_(t), value_(v), location_(location) {}
Token::Token(const Token& other) = default;
diff --git a/tools/gn/token.h b/tools/gn/token.h
index 126201c..46eb78e 100644
--- a/tools/gn/token.h
+++ b/tools/gn/token.h
@@ -5,7 +5,8 @@
#ifndef TOOLS_GN_TOKEN_H_
#define TOOLS_GN_TOKEN_H_
-#include "base/strings/string_piece.h"
+#include <string_view>
+
#include "tools/gn/location.h"
class Token {
@@ -57,11 +58,11 @@
};
Token();
- Token(const Location& location, Type t, const base::StringPiece& v);
+ Token(const Location& location, Type t, const std::string_view& v);
Token(const Token& other);
Type type() const { return type_; }
- const base::StringPiece& value() const { return value_; }
+ const std::string_view& value() const { return value_; }
const Location& location() const { return location_; }
void set_location(Location location) { location_ = location; }
LocationRange range() const {
@@ -78,7 +79,7 @@
private:
Type type_;
- base::StringPiece value_;
+ std::string_view value_;
Location location_;
};
diff --git a/tools/gn/tokenizer.cc b/tools/gn/tokenizer.cc
index 09f0b4b..73a1491 100644
--- a/tools/gn/tokenizer.cc
+++ b/tools/gn/tokenizer.cc
@@ -32,7 +32,7 @@
return c == '(' || c == ')' || c == '[' || c == ']' || c == '{' || c == '}';
}
-Token::Type GetSpecificOperatorType(base::StringPiece value) {
+Token::Type GetSpecificOperatorType(std::string_view value) {
if (value == "=")
return Token::EQUAL;
if (value == "+")
@@ -98,8 +98,8 @@
break;
size_t token_end = cur_;
- base::StringPiece token_value(&input_.data()[token_begin],
- token_end - token_begin);
+ std::string_view token_value(&input_.data()[token_begin],
+ token_end - token_begin);
if (type == Token::UNCLASSIFIED_OPERATOR) {
type = GetSpecificOperatorType(token_value);
@@ -148,7 +148,7 @@
}
// static
-size_t Tokenizer::ByteOffsetOfNthLine(const base::StringPiece& buf, int n) {
+size_t Tokenizer::ByteOffsetOfNthLine(const std::string_view& buf, int n) {
DCHECK_GT(n, 0);
if (n == 1)
@@ -168,7 +168,7 @@
}
// static
-bool Tokenizer::IsNewline(const base::StringPiece& buffer, size_t offset) {
+bool Tokenizer::IsNewline(const std::string_view& buffer, size_t offset) {
DCHECK(offset < buffer.size());
// We may need more logic here to handle different line ending styles.
return buffer[offset] == '\n';
diff --git a/tools/gn/tokenizer.h b/tools/gn/tokenizer.h
index 7b66ac0..41451ee 100644
--- a/tools/gn/tokenizer.h
+++ b/tools/gn/tokenizer.h
@@ -7,10 +7,10 @@
#include <stddef.h>
+#include <string_view>
#include <vector>
#include "base/macros.h"
-#include "base/strings/string_piece.h"
#include "tools/gn/err.h"
#include "tools/gn/token.h"
@@ -27,11 +27,11 @@
//
// This is a helper function for error output so that the tokenizer's
// notion of lines can be used elsewhere.
- static size_t ByteOffsetOfNthLine(const base::StringPiece& buf, int n);
+ static size_t ByteOffsetOfNthLine(const std::string_view& buf, int n);
// Returns true if the given offset of the string piece counts as a newline.
// The offset must be in the buffer.
- static bool IsNewline(const base::StringPiece& buffer, size_t offset);
+ static bool IsNewline(const std::string_view& buffer, size_t offset);
static bool IsIdentifierFirstChar(char c);
@@ -77,7 +77,7 @@
std::vector<Token> tokens_;
const InputFile* input_file_;
- const base::StringPiece input_;
+ const std::string_view input_;
Err* err_;
size_t cur_ = 0; // Byte offset into input buffer.
diff --git a/tools/gn/toolchain.h b/tools/gn/toolchain.h
index afab7f3..fbeda8f 100644
--- a/tools/gn/toolchain.h
+++ b/tools/gn/toolchain.h
@@ -6,9 +6,9 @@
#define TOOLS_GN_TOOLCHAIN_H_
#include <memory>
+#include <string_view>
#include "base/logging.h"
-#include "base/strings/string_piece.h"
#include "tools/gn/item.h"
#include "tools/gn/label_ptr.h"
#include "tools/gn/scope.h"
diff --git a/tools/gn/variables.h b/tools/gn/variables.h
index 09f2c18..60769d4 100644
--- a/tools/gn/variables.h
+++ b/tools/gn/variables.h
@@ -6,8 +6,7 @@
#define TOOLS_GN_VARIABLES_H_
#include <map>
-
-#include "base/strings/string_piece.h"
+#include <string_view>
namespace variables {
@@ -337,7 +336,7 @@
const char* help;
};
-typedef std::map<base::StringPiece, VariableInfo> VariableInfoMap;
+typedef std::map<std::string_view, VariableInfo> VariableInfoMap;
// Returns the built-in readonly variables.
// Note: this is used only for help so this getter is not threadsafe.
diff --git a/tools/gn/visibility.cc b/tools/gn/visibility.cc
index 75039e9..babbacc 100644
--- a/tools/gn/visibility.cc
+++ b/tools/gn/visibility.cc
@@ -5,8 +5,8 @@
#include "tools/gn/visibility.h"
#include <memory>
+#include <string_view>
-#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/values.h"
#include "tools/gn/err.h"
diff --git a/tools/gn/visual_studio_writer.cc b/tools/gn/visual_studio_writer.cc
index 217075b..0a4c6a5 100644
--- a/tools/gn/visual_studio_writer.cc
+++ b/tools/gn/visual_studio_writer.cc
@@ -98,16 +98,16 @@
std::string kits_path;
#if defined(OS_WIN)
- const base::char16* const subkeys[] = {
+ const char16_t* const subkeys[] = {
u"SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
u"SOFTWARE\\Wow6432Node\\Microsoft\\Windows Kits\\Installed Roots"};
- base::string16 value_name =
+ std::u16string value_name =
base::ASCIIToUTF16("KitsRoot") + base::ASCIIToUTF16(kWindowsKitsVersion);
- for (const base::char16* subkey : subkeys) {
+ for (const char16_t* subkey : subkeys) {
base::win::RegKey key(HKEY_LOCAL_MACHINE, subkey, KEY_READ);
- base::string16 value;
+ std::u16string value;
if (key.ReadValue(value_name.c_str(), &value) == ERROR_SUCCESS) {
kits_path = base::UTF16ToUTF8(value);
break;
@@ -175,13 +175,13 @@
// Returns a string piece pointing into the input string identifying the parent
// directory path, excluding the last slash. Note that the input pointer must
// outlive the output.
-base::StringPiece FindParentDir(const std::string* path) {
+std::string_view FindParentDir(const std::string* path) {
DCHECK(path && !path->empty());
for (int i = static_cast<int>(path->size()) - 2; i >= 0; --i) {
if (IsSlash((*path)[i]))
- return base::StringPiece(path->data(), i);
+ return std::string_view(path->data(), i);
}
- return base::StringPiece();
+ return std::string_view();
}
bool FilterTargets(const BuildSettings* build_settings,
@@ -697,7 +697,7 @@
filter_path_output.WriteFile(target_relative_out, *file_and_type.file);
std::string target_relative_path = target_relative_out.str();
ConvertPathToSystem(&target_relative_path);
- base::StringPiece filter_path = FindParentDir(&target_relative_path);
+ std::string_view filter_path = FindParentDir(&target_relative_path);
if (!filter_path.empty()) {
std::string filter_path_str(filter_path);
@@ -806,9 +806,9 @@
root_folder_path_.clear();
// Get all project directories. Create solution folder for each directory.
- std::map<base::StringPiece, SolutionEntry*> processed_paths;
+ std::map<std::string_view, SolutionEntry*> processed_paths;
for (const std::unique_ptr<SolutionProject>& project : projects_) {
- base::StringPiece folder_path = project->label_dir_path;
+ std::string_view folder_path = project->label_dir_path;
if (IsSlash(folder_path[folder_path.size() - 1]))
folder_path = folder_path.substr(0, folder_path.size() - 1);
auto it = processed_paths.find(folder_path);
@@ -856,7 +856,7 @@
continue;
SolutionEntry* folder = solution_folder.get();
- base::StringPiece parent_path;
+ std::string_view parent_path;
while ((parent_path = FindParentDir(&folder->path)) != root_folder_path_) {
auto it = processed_paths.find(parent_path);
if (it != processed_paths.end()) {
diff --git a/tools/gn/xcode_object.cc b/tools/gn/xcode_object.cc
index 248661a..7509547 100644
--- a/tools/gn/xcode_object.cc
+++ b/tools/gn/xcode_object.cc
@@ -140,7 +140,7 @@
{"y", "sourcecode.yacc"},
};
-const char* GetSourceType(const base::StringPiece& ext) {
+const char* GetSourceType(const std::string_view& ext) {
for (size_t i = 0; i < arraysize(kSourceTypeForExt); ++i) {
if (kSourceTypeForExt[i].ext == ext)
return kSourceTypeForExt[i].source_type;
@@ -149,11 +149,11 @@
return "text";
}
-bool HasExplicitFileType(const base::StringPiece& ext) {
+bool HasExplicitFileType(const std::string_view& ext) {
return ext == "dart";
}
-bool IsSourceFileForIndexing(const base::StringPiece& ext) {
+bool IsSourceFileForIndexing(const std::string_view& ext) {
return ext == "c" || ext == "cc" || ext == "cpp" || ext == "cxx" ||
ext == "m" || ext == "mm";
}
@@ -467,7 +467,7 @@
PrintProperty(out, rules, "explicitFileType", type_);
PrintProperty(out, rules, "includeInIndex", 0u);
} else {
- base::StringPiece ext = FindExtension(&name_);
+ std::string_view ext = FindExtension(&name_);
if (HasExplicitFileType(ext))
PrintProperty(out, rules, "explicitFileType", GetSourceType(ext));
else
@@ -547,7 +547,7 @@
}
PBXGroup* group = nullptr;
- base::StringPiece component(navigator_path.data(), sep);
+ std::string_view component(navigator_path.data(), sep);
for (const auto& child : children_) {
if (child->Class() != PBXGroupClass)
continue;
@@ -692,7 +692,7 @@
PBXNativeTarget* target) {
PBXFileReference* file_reference =
sources_->AddSourceFile(navigator_path, source_path);
- base::StringPiece ext = FindExtension(&source_path);
+ std::string_view ext = FindExtension(&source_path);
if (!IsSourceFileForIndexing(ext))
return;
@@ -736,7 +736,7 @@
const std::string& output_type,
const std::string& shell_script,
const PBXAttributes& extra_attributes) {
- base::StringPiece ext = FindExtension(&output_name);
+ std::string_view ext = FindExtension(&output_name);
PBXFileReference* product = static_cast<PBXFileReference*>(
products_->AddChild(std::make_unique<PBXFileReference>(
std::string(), output_name,
diff --git a/tools/gn/xml_element_writer.cc b/tools/gn/xml_element_writer.cc
index 360d8af..f94878c 100644
--- a/tools/gn/xml_element_writer.cc
+++ b/tools/gn/xml_element_writer.cc
@@ -8,13 +8,13 @@
XmlAttributes::XmlAttributes() = default;
-XmlAttributes::XmlAttributes(const base::StringPiece& attr_key,
- const base::StringPiece& attr_value) {
+XmlAttributes::XmlAttributes(const std::string_view& attr_key,
+ const std::string_view& attr_value) {
add(attr_key, attr_value);
}
-XmlAttributes& XmlAttributes::add(const base::StringPiece& attr_key,
- const base::StringPiece& attr_value) {
+XmlAttributes& XmlAttributes::add(const std::string_view& attr_key,
+ const std::string_view& attr_value) {
push_back(std::make_pair(attr_key, attr_value));
return *this;
}
@@ -50,7 +50,7 @@
}
}
-void XmlElementWriter::Text(const base::StringPiece& content) {
+void XmlElementWriter::Text(const std::string_view& content) {
StartContent(false);
out_ << content;
}
diff --git a/tools/gn/xml_element_writer.h b/tools/gn/xml_element_writer.h
index 1f68a7d..b276052 100644
--- a/tools/gn/xml_element_writer.h
+++ b/tools/gn/xml_element_writer.h
@@ -8,22 +8,22 @@
#include <memory>
#include <ostream>
#include <string>
+#include <string_view>
#include <utility>
#include <vector>
#include "base/macros.h"
-#include "base/strings/string_piece.h"
// Vector of XML attribute key-value pairs.
class XmlAttributes
- : public std::vector<std::pair<base::StringPiece, base::StringPiece>> {
+ : public std::vector<std::pair<std::string_view, std::string_view>> {
public:
XmlAttributes();
- XmlAttributes(const base::StringPiece& attr_key,
- const base::StringPiece& attr_value);
+ XmlAttributes(const std::string_view& attr_key,
+ const std::string_view& attr_value);
- XmlAttributes& add(const base::StringPiece& attr_key,
- const base::StringPiece& attr_value);
+ XmlAttributes& add(const std::string_view& attr_key,
+ const std::string_view& attr_value);
};
// Helper class for writing XML elements. New XML element is started in
@@ -54,7 +54,7 @@
~XmlElementWriter();
// Writes arbitrary XML element text.
- void Text(const base::StringPiece& content);
+ void Text(const std::string_view& content);
// Starts new XML sub-element. Caller must ensure that parent element outlives
// its children.
