Define string16 in terms of std::u16string.
This can be done now that we have C++17 support. The typedef is left for
simplicity. It will be replaced in a separate pass.
Remove wstring completely. On Windows we now use explicit 16-bit strings
and cast to make syscalls work. A new helper is added to support this.
Remove some unnecessary conversion functions and NACL defines.
Change-Id: I30c5b35c31e59510474fff71dc7256fb56cda641
Reviewed-on: https://gn-review.googlesource.com/c/gn/+/6020
Commit-Queue: Brett Wilson <brettw@chromium.org>
Reviewed-by: Scott Graham <scottmg@chromium.org>
diff --git a/base/bind_internal.h b/base/bind_internal.h
index 0dc59e6..510fcea 100644
--- a/base/bind_internal.h
+++ b/base/bind_internal.h
@@ -7,6 +7,7 @@
#include <stddef.h>
+#include <tuple>
#include <type_traits>
#include <utility>
diff --git a/base/command_line.cc b/base/command_line.cc
index 792d322..b2bf5a8 100644
--- a/base/command_line.cc
+++ b/base/command_line.cc
@@ -6,6 +6,7 @@
#include <algorithm>
#include <ostream>
+#include <string_view>
#include "base/files/file_path.h"
#include "base/logging.h"
@@ -38,7 +39,7 @@
// By putting slash last, we can control whether it is treaded as a switch
// value by changing the value of switch_prefix_count to be one less than
// the array size.
-const CommandLine::CharType* const kSwitchPrefixes[] = {L"--", L"-", L"/"};
+const CommandLine::CharType* const kSwitchPrefixes[] = {u"--", u"-", u"/"};
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
// Unixes don't use slash as a switch.
const CommandLine::CharType* const kSwitchPrefixes[] = {"--", "-"};
@@ -110,18 +111,18 @@
bool quote_placeholders) {
// We follow the quoting rules of CommandLineToArgvW.
// http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
- string16 quotable_chars(L" \\\"");
+ string16 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(L'%');
+ quotable_chars.push_back('%');
if (arg.find_first_of(quotable_chars) == string16::npos) {
// No quoting necessary.
return arg;
}
string16 out;
- out.push_back(L'"');
+ out.push_back('"');
for (size_t i = 0; i < arg.size(); ++i) {
if (arg[i] == '\\') {
// Find the extent of this run of backslashes.
@@ -185,7 +186,8 @@
// static
void CommandLine::set_slash_is_not_a_switch() {
// The last switch prefix should be slash, so adjust the size to skip it.
- DCHECK_EQ(wcscmp(kSwitchPrefixes[arraysize(kSwitchPrefixes) - 1], L"/"), 0);
+ DCHECK(std::u16string_view(kSwitchPrefixes[arraysize(kSwitchPrefixes) - 1]) ==
+ std::u16string_view(u"/"));
switch_prefix_count = arraysize(kSwitchPrefixes) - 1;
}
@@ -212,7 +214,8 @@
current_process_commandline_ = new CommandLine(NO_PROGRAM);
#if defined(OS_WIN)
- current_process_commandline_->ParseFromString(::GetCommandLineW());
+ current_process_commandline_->ParseFromString(
+ reinterpret_cast<const char16_t*>(::GetCommandLineW()));
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
current_process_commandline_->InitFromArgv(argc, argv);
#else
@@ -380,7 +383,7 @@
void CommandLine::AppendArg(const std::string& value) {
#if defined(OS_WIN)
DCHECK(IsStringUTF8(value));
- AppendArgNative(UTF8ToWide(value));
+ AppendArgNative(UTF8ToUTF16(value));
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
AppendArgNative(value);
#else
@@ -428,8 +431,9 @@
return;
int num_args = 0;
- wchar_t** args = NULL;
- args = ::CommandLineToArgvW(command_line_string.c_str(), &num_args);
+ char16_t** args = NULL;
+ args = reinterpret_cast<char16_t**>(::CommandLineToArgvW(
+ reinterpret_cast<LPCWSTR>(command_line_string.c_str()), &num_args));
DPLOG_IF(FATAL, !args) << "CommandLineToArgvW failed on command line: "
<< UTF16ToUTF8(command_line);
diff --git a/base/compiler_specific.h b/base/compiler_specific.h
index 4224197..78fcbaf 100644
--- a/base/compiler_specific.h
+++ b/base/compiler_specific.h
@@ -159,7 +159,7 @@
#endif
// MemorySanitizer annotations.
-#if defined(MEMORY_SANITIZER) && !defined(OS_NACL)
+#if defined(MEMORY_SANITIZER)
#include <sanitizer/msan_interface.h>
// Mark a memory region fully initialized.
diff --git a/base/containers/vector_buffer.h b/base/containers/vector_buffer.h
index a72c1ed..d40438d 100644
--- a/base/containers/vector_buffer.h
+++ b/base/containers/vector_buffer.h
@@ -39,7 +39,7 @@
public:
constexpr VectorBuffer() = default;
-#if defined(__clang__) && !defined(__native_client__)
+#if defined(__clang__)
// This constructor converts an uninitialized void* to a T* which triggers
// clang Control Flow Integrity. Since this is as-designed, disable.
__attribute__((no_sanitize("cfi-unrelated-cast", "vptr")))
diff --git a/base/environment.cc b/base/environment.cc
index 7f0e5d9..41951b7 100644
--- a/base/environment.cc
+++ b/base/environment.cc
@@ -57,15 +57,17 @@
private:
bool GetVarImpl(StringPiece variable_name, std::string* result) {
#if defined(OS_WIN)
- DWORD value_length =
- ::GetEnvironmentVariable(UTF8ToWide(variable_name).c_str(), nullptr, 0);
+ DWORD value_length = ::GetEnvironmentVariable(
+ reinterpret_cast<LPCWSTR>(UTF8ToUTF16(variable_name).c_str()), nullptr,
+ 0);
if (value_length == 0)
return false;
if (result) {
- std::unique_ptr<wchar_t[]> value(new wchar_t[value_length]);
- ::GetEnvironmentVariable(UTF8ToWide(variable_name).c_str(), value.get(),
- value_length);
- *result = WideToUTF8(value.get());
+ std::unique_ptr<char16_t[]> value(new char16_t[value_length]);
+ ::GetEnvironmentVariable(
+ reinterpret_cast<LPCWSTR>(UTF8ToUTF16(variable_name).c_str()),
+ reinterpret_cast<LPWSTR>(value.get()), value_length);
+ *result = UTF16ToUTF8(value.get());
}
return true;
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
@@ -82,8 +84,9 @@
bool SetVarImpl(StringPiece variable_name, const std::string& new_value) {
#if defined(OS_WIN)
// On success, a nonzero value is returned.
- return !!SetEnvironmentVariable(UTF8ToWide(variable_name).c_str(),
- UTF8ToWide(new_value).c_str());
+ return !!SetEnvironmentVariable(
+ reinterpret_cast<LPCWSTR>(UTF8ToUTF16(variable_name).c_str()),
+ reinterpret_cast<LPCWSTR>(UTF8ToUTF16(new_value).c_str()));
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
// On success, zero is returned.
return !setenv(variable_name.data(), new_value.c_str(), 1);
@@ -93,7 +96,8 @@
bool UnSetVarImpl(StringPiece variable_name) {
#if defined(OS_WIN)
// On success, a nonzero value is returned.
- return !!SetEnvironmentVariable(UTF8ToWide(variable_name).c_str(), nullptr);
+ return !!SetEnvironmentVariable(
+ reinterpret_cast<LPCWSTR>(UTF8ToUTF16(variable_name).c_str()), nullptr);
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
// On success, zero is returned.
return !unsetenv(variable_name.data());
@@ -143,14 +147,14 @@
#if defined(OS_WIN)
-string16 AlterEnvironment(const wchar_t* env, const EnvironmentMap& changes) {
+string16 AlterEnvironment(const char16_t* env, const EnvironmentMap& changes) {
string16 result;
// First copy all unmodified values to the output.
size_t cur_env = 0;
string16 key;
while (env[cur_env]) {
- const wchar_t* line = &env[cur_env];
+ const char16_t* line = &env[cur_env];
size_t line_length = ParseEnvLine(line, &key);
// Keep only values not specified in the change vector.
diff --git a/base/environment.h b/base/environment.h
index 82af987..201b1a8 100644
--- a/base/environment.h
+++ b/base/environment.h
@@ -61,7 +61,7 @@
// 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 wchar_t* env, const EnvironmentMap& changes);
+string16 AlterEnvironment(const char16_t* env, const EnvironmentMap& changes);
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
diff --git a/base/files/file.cc b/base/files/file.cc
index 98fa3a6..8c04016 100644
--- a/base/files/file.cc
+++ b/base/files/file.cc
@@ -19,12 +19,10 @@
File::File()
: error_details_(FILE_ERROR_FAILED), created_(false), async_(false) {}
-#if !defined(OS_NACL)
File::File(const FilePath& path, uint32_t flags)
: error_details_(FILE_OK), created_(false), async_(false) {
Initialize(path, flags);
}
-#endif
File::File(PlatformFile platform_file)
: file_(platform_file),
@@ -68,7 +66,6 @@
return *this;
}
-#if !defined(OS_NACL)
void File::Initialize(const FilePath& path, uint32_t flags) {
if (path.ReferencesParent()) {
#if defined(OS_WIN)
@@ -83,7 +80,6 @@
}
DoInitialize(path, flags);
}
-#endif
std::string File::ErrorToString(Error error) {
switch (error) {
diff --git a/base/files/file.h b/base/files/file.h
index 61239ad..3355030 100644
--- a/base/files/file.h
+++ b/base/files/file.h
@@ -22,7 +22,7 @@
namespace base {
-#if defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL) || \
+#if defined(OS_BSD) || defined(OS_MACOSX) || \
defined(OS_ANDROID) && __ANDROID_API__ < 21
typedef struct stat stat_wrapper_t;
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
diff --git a/base/files/file_enumerator_win.cc b/base/files/file_enumerator_win.cc
index 803b7bd..aa884ea 100644
--- a/base/files/file_enumerator_win.cc
+++ b/base/files/file_enumerator_win.cc
@@ -9,6 +9,7 @@
#include <string.h>
#include "base/logging.h"
+#include "base/win/win_util.h"
namespace base {
@@ -23,7 +24,7 @@
case FileEnumerator::FolderSearchPolicy::MATCH_ONLY:
return root_path.Append(pattern);
case FileEnumerator::FolderSearchPolicy::ALL:
- return root_path.Append(L"*");
+ return root_path.Append(u"*");
}
NOTREACHED();
return {};
@@ -42,7 +43,7 @@
}
FilePath FileEnumerator::FileInfo::GetName() const {
- return FilePath(find_data_.cFileName);
+ return FilePath(reinterpret_cast<const char16_t*>(find_data_.cFileName));
}
int64_t FileEnumerator::FileInfo::GetSize() const {
@@ -86,7 +87,7 @@
FolderSearchPolicy folder_search_policy)
: recursive_(recursive),
file_type_(file_type),
- pattern_(!pattern.empty() ? pattern : L"*"),
+ pattern_(!pattern.empty() ? pattern : u"*"),
folder_search_policy_(folder_search_policy) {
// INCLUDE_DOT_DOT must not be specified if recursive.
DCHECK(!(recursive && (INCLUDE_DOT_DOT & file_type_)));
@@ -119,7 +120,7 @@
// Start a new find operation.
const FilePath src =
BuildSearchFilter(folder_search_policy_, root_path_, pattern_);
- find_handle_ = FindFirstFileEx(src.value().c_str(),
+ find_handle_ = FindFirstFileEx(ToWCharT(&src.value()),
FindExInfoBasic, // Omit short name.
&find_data_, FindExSearchNameMatch,
nullptr, FIND_FIRST_EX_LARGE_FETCH);
@@ -143,13 +144,13 @@
// files in the root search directory, but for those directories which
// were matched, we want to enumerate all files inside them. This will
// happen when the handle is empty.
- pattern_ = L"*";
+ pattern_ = u"*";
}
continue;
}
- const FilePath filename(find_data_.cFileName);
+ const FilePath filename(reinterpret_cast<char16_t*>(find_data_.cFileName));
if (ShouldSkip(filename))
continue;
@@ -163,7 +164,7 @@
// add it to pending_paths_ so we scan it after we finish scanning this
// directory. However, don't do recursion through reparse points or we
// may end up with an infinite cycle.
- DWORD attributes = GetFileAttributes(abs_path.value().c_str());
+ DWORD attributes = GetFileAttributes(ToWCharT(&abs_path.value()));
if (!(attributes & FILE_ATTRIBUTE_REPARSE_POINT))
pending_paths_.push(abs_path);
}
@@ -183,7 +184,7 @@
case FolderSearchPolicy::ALL:
// ALL policy enumerates all files, we need to check pattern match
// manually.
- return PathMatchSpec(src.value().c_str(), pattern_.c_str()) == TRUE;
+ return PathMatchSpec(ToWCharT(&src.value()), ToWCharT(&pattern_)) == TRUE;
}
NOTREACHED();
return false;
diff --git a/base/files/file_path.cc b/base/files/file_path.cc
index 014bc9e..f0e1acb 100644
--- a/base/files/file_path.cc
+++ b/base/files/file_path.cc
@@ -199,10 +199,6 @@
#endif // defined(FILE_PATH_USES_DRIVE_LETTERS)
}
-std::ostream& operator<<(std::ostream& out, const FilePath& file_path) {
- return out << file_path.value();
-}
-
// static
bool FilePath::IsSeparator(CharType character) {
for (size_t i = 0; i < kSeparatorsLength - 1; ++i) {
@@ -578,22 +574,8 @@
return std::string();
}
-std::string FilePath::AsUTF8Unsafe() const {
- return WideToUTF8(value());
-}
-
-string16 FilePath::AsUTF16Unsafe() const {
- return value();
-}
-
-// static
-FilePath FilePath::FromUTF8Unsafe(StringPiece utf8) {
- return FilePath(UTF8ToWide(utf8));
-}
-
-// static
-FilePath FilePath::FromUTF16Unsafe(StringPiece16 utf16) {
- return FilePath(utf16);
+std::string FilePath::As8Bit() const {
+ return UTF16ToUTF8(value());
}
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
@@ -607,24 +589,10 @@
return std::string();
}
-std::string FilePath::AsUTF8Unsafe() const {
+std::string FilePath::As8Bit() const {
return value();
}
-string16 FilePath::AsUTF16Unsafe() const {
- return UTF8ToUTF16(value());
-}
-
-// static
-FilePath FilePath::FromUTF8Unsafe(StringPiece utf8) {
- return FilePath(utf8);
-}
-
-// static
-FilePath FilePath::FromUTF16Unsafe(StringPiece16 utf16) {
- return FilePath(UTF16ToUTF8(utf16));
-}
-
#endif // defined(OS_WIN)
void FilePath::StripTrailingSeparatorsInternal() {
diff --git a/base/files/file_path.h b/base/files/file_path.h
index 1717cba..a85c1aa 100644
--- a/base/files/file_path.h
+++ b/base/files/file_path.h
@@ -9,7 +9,7 @@
//
// POSIX Windows
// --------------- ----------------------------------
-// Fundamental type char[] wchar_t[]
+// Fundamental type char[] char16_t[]
// Encoding unspecified* UTF-16
// Separator / \, tolerant of /
// Drive letters no case-insensitive A-Z followed by :
@@ -50,7 +50,7 @@
//
// To aid in initialization of FilePath objects from string literals, a
// FILE_PATH_LITERAL macro is provided, which accounts for the difference
-// between char[]-based pathnames on POSIX systems and wchar_t[]-based
+// between char[]-based pathnames on POSIX systems and char16_t[]-based
// pathnames on Windows.
//
// As a precaution against premature truncation, paths can't contain NULs.
@@ -142,9 +142,9 @@
class FilePath {
public:
#if defined(OS_WIN)
- // On Windows, for Unicode-aware applications, native pathnames are wchar_t
+ // On Windows, for Unicode-aware applications, native pathnames are char16_t
// arrays encoded in UTF-16.
- typedef std::wstring StringType;
+ typedef std::u16string StringType;
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
// On most platforms, native pathnames are char arrays, and the encoding
// may or may not be specified. On Mac OS X, native pathnames are encoded
@@ -306,10 +306,10 @@
FilePath Append(StringPieceType component) const WARN_UNUSED_RESULT;
FilePath Append(const FilePath& component) const WARN_UNUSED_RESULT;
- // Although Windows StringType is std::wstring, since the encoding it uses for
- // paths is well defined, it can handle ASCII path components as well.
- // Mac uses UTF8, and since ASCII is a subset of that, it works there as well.
- // On Linux, although it can use any 8-bit encoding for paths, we assume that
+ // Although Windows StringType is std::u16string, since the encoding it uses
+ // for paths is well defined, it can handle ASCII path components as well. Mac
+ // uses UTF8, and since ASCII is a subset of that, it works there as well. On
+ // 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;
@@ -346,36 +346,8 @@
// known-ASCII filename.
std::string MaybeAsASCII() const;
- // Return the path as UTF-8.
- //
- // This function is *unsafe* as there is no way to tell what encoding is
- // used in file names on POSIX systems other than Mac and Chrome OS,
- // although UTF-8 is practically used everywhere these days. To mitigate
- // the encoding issue, this function internally calls
- // SysNativeMBToWide() on POSIX systems other than Mac and Chrome OS,
- // per assumption that the current locale's encoding is used in file
- // names, but this isn't a perfect solution.
- //
- // Once it becomes safe to to stop caring about non-UTF-8 file names,
- // the SysNativeMBToWide() hack will be removed from the code, along
- // with "Unsafe" in the function name.
- std::string AsUTF8Unsafe() const;
-
- // Similar to AsUTF8Unsafe, but returns UTF-16 instead.
- string16 AsUTF16Unsafe() const;
-
- // Returns a FilePath object from a path name in UTF-8. This function
- // should only be used for cases where you are sure that the input
- // string is UTF-8.
- //
- // Like AsUTF8Unsafe(), this function is unsafe. This function
- // internally calls SysWideToNativeMB() on POSIX systems other than Mac
- // and Chrome OS, to mitigate the encoding issue. See the comment at
- // AsUTF8Unsafe() for details.
- static FilePath FromUTF8Unsafe(StringPiece utf8);
-
- // Similar to FromUTF8Unsafe, but accepts UTF-16 instead.
- static FilePath FromUTF16Unsafe(StringPiece16 utf16);
+ // Return the path as 8-bit. On Linux this isn't guaranteed to be UTF-8.
+ std::string As8Bit() const;
// Normalize all path separators to backslash on Windows
// (if FILE_PATH_USES_WIN_SEPARATORS is true), or do nothing on POSIX systems.
@@ -396,18 +368,13 @@
StringType path_;
};
-std::ostream& operator<<(std::ostream& out, const FilePath& file_path);
-
} // namespace base
-// Macros for string literal initialization of FilePath::CharType[], and for
-// using a FilePath::CharType[] in a printf-style format string.
+// Macros for string literal initialization of FilePath::CharType[].
#if defined(OS_WIN)
-#define FILE_PATH_LITERAL(x) L##x
-#define PRFilePath "ls"
+#define FILE_PATH_LITERAL(x) u##x
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
#define FILE_PATH_LITERAL(x) x
-#define PRFilePath "s"
#endif // OS_WIN
namespace std {
diff --git a/base/files/file_posix.cc b/base/files/file_posix.cc
index ed9a5e2..90b80d0 100644
--- a/base/files/file_posix.cc
+++ b/base/files/file_posix.cc
@@ -24,7 +24,7 @@
namespace {
-#if defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL) || \
+#if defined(OS_BSD) || defined(OS_MACOSX) || \
defined(OS_ANDROID) && __ANDROID_API__ < 21
int CallFstat(int fd, stat_wrapper_t* sb) {
return fstat(fd, sb);
@@ -35,9 +35,9 @@
}
#endif
-// NaCl doesn't provide the following system calls, so either simulate them or
-// wrap them in order to minimize the number of #ifdef's in this file.
-#if !defined(OS_NACL) && !defined(OS_AIX)
+// Some systems don't provide the following system calls, so either simulate
+// them or wrap them in order to minimize the number of #ifdef's in this file.
+#if !defined(OS_AIX)
bool IsOpenAppend(PlatformFile file) {
return (fcntl(file, F_GETFL) & O_APPEND) != 0;
}
@@ -59,7 +59,7 @@
}
#endif
-#else // defined(OS_NACL) && !defined(OS_AIX)
+#else // !defined(OS_AIX)
bool IsOpenAppend(PlatformFile file) {
// NaCl doesn't implement fcntl. Since NaCl's write conforms to the POSIX
@@ -77,7 +77,7 @@
NOTIMPLEMENTED(); // NaCl doesn't implement flock struct.
return File::FILE_ERROR_INVALID_OPERATION;
}
-#endif // defined(OS_NACL)
+#endif // defined(OS_AIX)
} // namespace
@@ -303,9 +303,7 @@
case EPERM:
return FILE_ERROR_ACCESS_DENIED;
case EBUSY:
-#if !defined(OS_NACL) // ETXTBSY not defined by NaCl.
case ETXTBSY:
-#endif
return FILE_ERROR_IN_USE;
case EEXIST:
return FILE_ERROR_EXISTS;
@@ -329,8 +327,6 @@
}
}
-// NaCl doesn't implement system calls to open files directly.
-#if !defined(OS_NACL)
// TODO(erikkay): does it make sense to support FLAG_EXCLUSIVE_* here?
void File::DoInitialize(const FilePath& path, uint32_t flags) {
DCHECK(!IsValid());
@@ -409,7 +405,6 @@
error_details_ = FILE_OK;
file_.reset(descriptor);
}
-#endif // !defined(OS_NACL)
bool File::Flush() {
DCHECK(IsValid());
diff --git a/base/files/file_util.cc b/base/files/file_util.cc
index 9a98a0b..25b7aab 100644
--- a/base/files/file_util.cc
+++ b/base/files/file_util.cc
@@ -23,7 +23,6 @@
namespace base {
-#if !defined(OS_NACL_NONSFI)
namespace {
// The maximum number of 'uniquified' files we will try to create.
@@ -47,9 +46,9 @@
// We open the file in binary format even if they are text files because
// we are just comparing that bytes are exactly same in both files and not
// doing anything smart with text formatting.
- std::ifstream file1(filename1.value().c_str(),
+ std::ifstream file1(filename1.As8Bit().c_str(),
std::ios::in | std::ios::binary);
- std::ifstream file2(filename2.value().c_str(),
+ std::ifstream file2(filename2.As8Bit().c_str(),
std::ios::in | std::ios::binary);
// Even if both files aren't openable (and thus, in some sense, "equal"),
@@ -77,8 +76,8 @@
}
bool TextContentsEqual(const FilePath& filename1, const FilePath& filename2) {
- std::ifstream file1(filename1.value().c_str(), std::ios::in);
- std::ifstream file2(filename2.value().c_str(), std::ios::in);
+ std::ifstream file1(filename1.As8Bit().c_str(), std::ios::in);
+ std::ifstream file2(filename2.As8Bit().c_str(), std::ios::in);
// Even if both files aren't openable (and thus, in some sense, "equal"),
// any unusable file yields a result of "false".
@@ -114,7 +113,6 @@
return true;
}
-#endif // !defined(OS_NACL_NONSFI)
bool ReadFileToStringWithMaxSize(const FilePath& path,
std::string* contents,
@@ -133,15 +131,11 @@
// file size as a hint for chunk size if available.
constexpr int64_t kDefaultChunkSize = 1 << 16;
int64_t chunk_size;
-#if !defined(OS_NACL_NONSFI)
if (!GetFileSize(path, &chunk_size) || chunk_size <= 0)
chunk_size = kDefaultChunkSize - 1;
// We need to attempt to read at EOF for feof flag to be set so here we
// use |chunk_size| + 1.
chunk_size = std::min<uint64_t>(chunk_size, max_size) + 1;
-#else
- chunk_size = kDefaultChunkSize;
-#endif // !defined(OS_NACL_NONSFI)
size_t bytes_read_this_pass;
size_t bytes_read_so_far = 0;
bool read_status = true;
@@ -183,7 +177,6 @@
std::numeric_limits<size_t>::max());
}
-#if !defined(OS_NACL_NONSFI)
bool IsDirectoryEmpty(const FilePath& dir_path) {
FileEnumerator files(dir_path, false,
FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
@@ -212,15 +205,12 @@
return true;
}
-#endif // !defined(OS_NACL_NONSFI)
-
bool CloseFile(FILE* file) {
if (file == nullptr)
return true;
return fclose(file) == 0;
}
-#if !defined(OS_NACL_NONSFI)
bool TruncateFile(FILE* file) {
if (file == nullptr)
return false;
@@ -258,6 +248,5 @@
return -1;
}
-#endif // !defined(OS_NACL_NONSFI)
} // namespace base
diff --git a/base/files/file_util_posix.cc b/base/files/file_util_posix.cc
index eb07e64..966abc0 100644
--- a/base/files/file_util_posix.cc
+++ b/base/files/file_util_posix.cc
@@ -55,7 +55,7 @@
namespace {
-#if defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL) || \
+#if defined(OS_BSD) || defined(OS_MACOSX) || \
defined(OS_ANDROID) && __ANDROID_API__ < 21
int CallStat(const char* path, stat_wrapper_t* sb) {
return stat(path, sb);
@@ -72,7 +72,6 @@
}
#endif
-#if !defined(OS_NACL_NONSFI)
// Helper for VerifyPathControlledByUser.
bool VerifySpecificPathControlledByUser(const FilePath& path,
uid_t owner_uid,
@@ -179,7 +178,6 @@
NOTREACHED();
return false;
}
-#endif // !defined(OS_NACL_NONSFI)
#if !defined(OS_MACOSX)
// Appends |mode_char| to |mode| before the optional character set encoding; see
@@ -196,7 +194,6 @@
} // namespace
-#if !defined(OS_NACL_NONSFI)
FilePath MakeAbsoluteFilePath(const FilePath& input) {
char full_path[PATH_MAX];
if (realpath(input.value().c_str(), full_path) == nullptr)
@@ -251,7 +248,6 @@
*error = File::GetLastFileError();
return false;
}
-#endif // !defined(OS_NACL_NONSFI)
bool CreateLocalNonBlockingPipe(int fds[2]) {
#if defined(OS_LINUX)
@@ -288,15 +284,11 @@
}
bool SetCloseOnExec(int fd) {
-#if defined(OS_NACL_NONSFI)
- const int flags = 0;
-#else
const int flags = fcntl(fd, F_GETFD);
if (flags == -1)
return false;
if (flags & FD_CLOEXEC)
return true;
-#endif // defined(OS_NACL_NONSFI)
if (HANDLE_EINTR(fcntl(fd, F_SETFD, flags | FD_CLOEXEC)) == -1)
return false;
return true;
@@ -306,11 +298,9 @@
return access(path.value().c_str(), F_OK) == 0;
}
-#if !defined(OS_NACL_NONSFI)
bool PathIsWritable(const FilePath& path) {
return access(path.value().c_str(), W_OK) == 0;
}
-#endif // !defined(OS_NACL_NONSFI)
bool DirectoryExists(const FilePath& path) {
stat_wrapper_t file_info;
@@ -331,8 +321,6 @@
return total_read == bytes;
}
-#if !defined(OS_NACL_NONSFI)
-
int CreateAndOpenFdForTemporaryFileInDir(const FilePath& directory,
FilePath* path) {
*path = directory.Append(TempFileName());
@@ -575,7 +563,6 @@
results->FromStat(file_info);
return true;
}
-#endif // !defined(OS_NACL_NONSFI)
FILE* OpenFile(const FilePath& filename, const char* mode) {
// 'e' is unconditionally added below, so be sure there is not one already
@@ -603,15 +590,12 @@
return result;
}
-// NaCl doesn't implement system calls to open files directly.
-#if !defined(OS_NACL)
FILE* FileToFILE(File file, const char* mode) {
FILE* stream = fdopen(file.GetPlatformFile(), mode);
if (stream)
file.TakePlatformFile();
return stream;
}
-#endif // !defined(OS_NACL)
int ReadFile(const FilePath& filename, char* data, int max_size) {
int fd = HANDLE_EINTR(open(filename.value().c_str(), O_RDONLY));
@@ -649,8 +633,6 @@
return true;
}
-#if !defined(OS_NACL_NONSFI)
-
bool AppendToFile(const FilePath& filename, const char* data, int size) {
bool ret = true;
int fd = HANDLE_EINTR(open(filename.value().c_str(), O_WRONLY | O_APPEND));
@@ -783,5 +765,4 @@
}
#endif // !defined(OS_MACOSX)
-#endif // !defined(OS_NACL_NONSFI)
} // namespace base
diff --git a/base/files/file_util_win.cc b/base/files/file_util_win.cc
index 34d328b..8fba87a 100644
--- a/base/files/file_util_win.cc
+++ b/base/files/file_util_win.cc
@@ -29,6 +29,7 @@
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/win/scoped_handle.h"
+#include "base/win/win_util.h"
// #define needed to link in RtlGenRandom(), a.k.a. SystemFunction036. See the
// "Community Additions" comment on MSDN here:
@@ -61,7 +62,7 @@
if ((info.find_data().dwFileAttributes & FILE_ATTRIBUTE_READONLY) &&
(recursive || !info.IsDirectory())) {
::SetFileAttributes(
- current.value().c_str(),
+ ToWCharT(¤t.value()),
info.find_data().dwFileAttributes & ~FILE_ATTRIBUTE_READONLY);
}
@@ -70,11 +71,11 @@
if (recursive) {
this_result = DeleteFileRecursive(current, pattern, true);
if (this_result == ERROR_SUCCESS &&
- !::RemoveDirectory(current.value().c_str())) {
+ !::RemoveDirectory(ToWCharT(¤t.value()))) {
this_result = ::GetLastError();
}
}
- } else if (!::DeleteFile(current.value().c_str())) {
+ } else if (!::DeleteFile(ToWCharT(¤t.value()))) {
this_result = ::GetLastError();
}
if (result == ERROR_SUCCESS)
@@ -100,14 +101,14 @@
return ERROR_BAD_PATHNAME;
// Handle any path with wildcards.
- if (path.BaseName().value().find_first_of(L"*?") !=
+ if (path.BaseName().value().find_first_of(u"*?") !=
FilePath::StringType::npos) {
return DeleteFileRecursive(path.DirName(), path.BaseName().value(),
recursive);
}
// Report success if the file or path does not exist.
- const DWORD attr = ::GetFileAttributes(path.value().c_str());
+ const DWORD attr = ::GetFileAttributes(ToWCharT(&path.value()));
if (attr == INVALID_FILE_ATTRIBUTES) {
const DWORD error_code = ::GetLastError();
return (error_code == ERROR_FILE_NOT_FOUND ||
@@ -118,24 +119,24 @@
// Clear the read-only bit if it is set.
if ((attr & FILE_ATTRIBUTE_READONLY) &&
- !::SetFileAttributes(path.value().c_str(),
+ !::SetFileAttributes(ToWCharT(&path.value()),
attr & ~FILE_ATTRIBUTE_READONLY)) {
return ::GetLastError();
}
// Perform a simple delete on anything that isn't a directory.
if (!(attr & FILE_ATTRIBUTE_DIRECTORY)) {
- return ::DeleteFile(path.value().c_str()) ? ERROR_SUCCESS
- : ::GetLastError();
+ return ::DeleteFile(ToWCharT(&path.value())) ? ERROR_SUCCESS
+ : ::GetLastError();
}
if (recursive) {
- const DWORD error_code = DeleteFileRecursive(path, L"*", true);
+ const DWORD error_code = DeleteFileRecursive(path, u"*", true);
if (error_code != ERROR_SUCCESS)
return error_code;
}
- return ::RemoveDirectory(path.value().c_str()) ? ERROR_SUCCESS
- : ::GetLastError();
+ return ::RemoveDirectory(ToWCharT(&path.value())) ? ERROR_SUCCESS
+ : ::GetLastError();
}
std::string RandomDataToGUIDString(const uint64_t bytes[2]) {
@@ -185,8 +186,8 @@
} // namespace
FilePath MakeAbsoluteFilePath(const FilePath& input) {
- wchar_t file_path[MAX_PATH];
- if (!_wfullpath(file_path, input.value().c_str(), MAX_PATH))
+ char16_t file_path[MAX_PATH];
+ if (!_wfullpath(ToWCharT(file_path), ToWCharT(&input.value()), MAX_PATH))
return FilePath();
return FilePath(file_path);
}
@@ -208,7 +209,7 @@
if (path.value().length() >= MAX_PATH)
return false;
- return MoveFileEx(path.value().c_str(), NULL,
+ return MoveFileEx(ToWCharT(&path.value()), NULL,
MOVEFILE_DELAY_UNTIL_REBOOT | MOVEFILE_REPLACE_EXISTING) !=
FALSE;
}
@@ -218,7 +219,7 @@
File::Error* error) {
// Try a simple move first. It will only succeed when |to_path| doesn't
// already exist.
- if (::MoveFile(from_path.value().c_str(), to_path.value().c_str()))
+ if (::MoveFile(ToWCharT(&from_path.value()), ToWCharT(&to_path.value())))
return true;
File::Error move_error = File::OSErrorToFileError(GetLastError());
@@ -226,8 +227,8 @@
// succeed when |to_path| does exist. When writing to a network share, we may
// not be able to change the ACLs. Ignore ACL errors then
// (REPLACEFILE_IGNORE_MERGE_ERRORS).
- if (::ReplaceFile(to_path.value().c_str(), from_path.value().c_str(), NULL,
- REPLACEFILE_IGNORE_MERGE_ERRORS, NULL, NULL)) {
+ if (::ReplaceFile(ToWCharT(&to_path.value()), ToWCharT(&from_path.value()),
+ NULL, REPLACEFILE_IGNORE_MERGE_ERRORS, NULL, NULL)) {
return true;
}
// In the case of FILE_ERROR_NOT_FOUND from ReplaceFile, it is likely that
@@ -242,12 +243,13 @@
}
bool PathExists(const FilePath& path) {
- return (GetFileAttributes(path.value().c_str()) != INVALID_FILE_ATTRIBUTES);
+ return (GetFileAttributes(ToWCharT(&path.value())) !=
+ INVALID_FILE_ATTRIBUTES);
}
bool PathIsWritable(const FilePath& path) {
HANDLE dir =
- CreateFile(path.value().c_str(), FILE_ADD_FILE, kFileShareAll, NULL,
+ CreateFile(ToWCharT(&path.value()), FILE_ADD_FILE, kFileShareAll, NULL,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (dir == INVALID_HANDLE_VALUE)
@@ -258,15 +260,15 @@
}
bool DirectoryExists(const FilePath& path) {
- DWORD fileattr = GetFileAttributes(path.value().c_str());
+ DWORD fileattr = GetFileAttributes(ToWCharT(&path.value()));
if (fileattr != INVALID_FILE_ATTRIBUTES)
return (fileattr & FILE_ATTRIBUTE_DIRECTORY) != 0;
return false;
}
bool GetTempDir(FilePath* path) {
- wchar_t temp_path[MAX_PATH + 1];
- DWORD path_len = ::GetTempPath(MAX_PATH, temp_path);
+ char16_t temp_path[MAX_PATH + 1];
+ DWORD path_len = ::GetTempPath(MAX_PATH, ToWCharT(temp_path));
if (path_len >= MAX_PATH || path_len <= 0)
return false;
// TODO(evanm): the old behavior of this function was to always strip the
@@ -318,7 +320,7 @@
// Although it is nearly impossible to get a duplicate name with GUID, we
// still use a loop here in case it happens.
for (int i = 0; i < 100; ++i) {
- temp_name = dir.Append(ASCIIToUTF16(base::GenerateGUID()) + L".tmp");
+ temp_name = dir.Append(ASCIIToUTF16(base::GenerateGUID()) + u".tmp");
File file(temp_name,
File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE);
if (file.IsValid()) {
@@ -334,9 +336,9 @@
return false;
}
- wchar_t long_temp_name[MAX_PATH + 1];
- DWORD long_name_len =
- GetLongPathName(temp_name.value().c_str(), long_temp_name, MAX_PATH);
+ char16_t long_temp_name[MAX_PATH + 1];
+ DWORD long_name_len = GetLongPathName(ToWCharT(&temp_name.value()),
+ ToWCharT(long_temp_name), MAX_PATH);
if (long_name_len > MAX_PATH || long_name_len == 0) {
// GetLongPathName() failed, but we still have a temporary file.
*temp_file = std::move(temp_name);
@@ -364,7 +366,7 @@
new_dir_name.append(UTF8ToUTF16(GenerateGUID()));
path_to_create = base_dir.Append(new_dir_name);
- if (::CreateDirectory(path_to_create.value().c_str(), NULL)) {
+ if (::CreateDirectory(ToWCharT(&path_to_create.value()), NULL)) {
*new_dir = path_to_create;
return true;
}
@@ -384,13 +386,13 @@
bool CreateDirectoryAndGetError(const FilePath& full_path, File::Error* error) {
// If the path exists, we've succeeded if it's a directory, failed otherwise.
- const wchar_t* full_path_str = full_path.value().c_str();
- DWORD fileattr = ::GetFileAttributes(full_path_str);
+ DWORD fileattr = ::GetFileAttributes(ToWCharT(&full_path.value()));
if (fileattr != INVALID_FILE_ATTRIBUTES) {
if ((fileattr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
return true;
}
- DLOG(WARNING) << "CreateDirectory(" << full_path_str << "), "
+ DLOG(WARNING) << "CreateDirectory(" << UTF16ToUTF8(full_path.value())
+ << "), "
<< "conflicts with existing file.";
if (error) {
*error = File::FILE_ERROR_NOT_A_DIRECTORY;
@@ -418,7 +420,7 @@
return false;
}
- if (!::CreateDirectory(full_path_str, NULL)) {
+ if (!::CreateDirectory(ToWCharT(&full_path.value()), NULL)) {
DWORD error_code = ::GetLastError();
if (error_code == ERROR_ALREADY_EXISTS && DirectoryExists(full_path)) {
// This error code ERROR_ALREADY_EXISTS doesn't indicate whether we
@@ -429,8 +431,9 @@
} else {
if (error)
*error = File::OSErrorToFileError(error_code);
- DLOG(WARNING) << "Failed to create directory " << full_path_str
- << ", last error is " << error_code << ".";
+ DLOG(WARNING) << "Failed to create directory "
+ << UTF16ToUTF8(full_path.value()) << ", last error is "
+ << error_code << ".";
return false;
}
} else {
@@ -453,17 +456,18 @@
FilePath* out_drive_letter_path) {
// Get the mapping of drive letters to device paths.
const int kDriveMappingSize = 1024;
- wchar_t drive_mapping[kDriveMappingSize] = {'\0'};
- if (!::GetLogicalDriveStrings(kDriveMappingSize - 1, drive_mapping)) {
+ char16_t drive_mapping[kDriveMappingSize] = {'\0'};
+ if (!::GetLogicalDriveStrings(kDriveMappingSize - 1,
+ ToWCharT(drive_mapping))) {
DLOG(ERROR) << "Failed to get drive mapping.";
return false;
}
// The drive mapping is a sequence of null terminated strings.
// The last string is empty.
- wchar_t* drive_map_ptr = drive_mapping;
- wchar_t device_path_as_string[MAX_PATH];
- wchar_t drive[] = L" :";
+ char16_t* drive_map_ptr = drive_mapping;
+ char16_t device_path_as_string[MAX_PATH];
+ char16_t drive[] = u" :";
// For each string in the drive mapping, get the junction that links
// to it. If that junction is a prefix of |device_path|, then we
@@ -471,13 +475,14 @@
while (*drive_map_ptr) {
drive[0] = drive_map_ptr[0]; // Copy the drive letter.
- if (QueryDosDevice(drive, device_path_as_string, MAX_PATH)) {
+ if (QueryDosDevice(ToWCharT(drive), ToWCharT(device_path_as_string),
+ MAX_PATH)) {
FilePath device_path(device_path_as_string);
if (device_path == nt_device_path ||
device_path.IsParent(nt_device_path)) {
*out_drive_letter_path =
FilePath(drive + nt_device_path.value().substr(
- wcslen(device_path_as_string)));
+ wcslen(ToWCharT(device_path_as_string))));
return true;
}
}
@@ -499,9 +504,9 @@
// code below to a call to GetFinalPathNameByHandle(). The method this
// function uses is explained in the following msdn article:
// http://msdn.microsoft.com/en-us/library/aa366789(VS.85).aspx
- win::ScopedHandle file_handle(::CreateFile(path.value().c_str(), GENERIC_READ,
- kFileShareAll, NULL, OPEN_EXISTING,
- FILE_ATTRIBUTE_NORMAL, NULL));
+ win::ScopedHandle file_handle(
+ ::CreateFile(ToWCharT(&path.value()), GENERIC_READ, kFileShareAll, NULL,
+ OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL));
if (!file_handle.IsValid())
return false;
@@ -528,10 +533,11 @@
// not return kMaxPathLength. This would mean that only part of the
// path fit in |mapped_file_path|.
const int kMaxPathLength = MAX_PATH + 10;
- wchar_t mapped_file_path[kMaxPathLength];
+ char16_t mapped_file_path[kMaxPathLength];
bool success = false;
HANDLE cp = GetCurrentProcess();
- if (::GetMappedFileNameW(cp, file_view, mapped_file_path, kMaxPathLength)) {
+ if (::GetMappedFileNameW(cp, file_view, ToWCharT(mapped_file_path),
+ kMaxPathLength)) {
*nt_path = FilePath(mapped_file_path);
success = true;
}
@@ -547,7 +553,7 @@
bool GetFileInfo(const FilePath& file_path, File::Info* results) {
WIN32_FILE_ATTRIBUTE_DATA attr;
- if (!GetFileAttributesEx(file_path.value().c_str(), GetFileExInfoStandard,
+ if (!GetFileAttributesEx(ToWCharT(&file_path.value()), GetFileExInfoStandard,
&attr)) {
return false;
}
@@ -574,7 +580,7 @@
(strchr(mode, ',') != nullptr && strchr(mode, 'N') > strchr(mode, ',')));
string16 w_mode = ASCIIToUTF16(mode);
AppendModeCharacter(L'N', &w_mode);
- return _wfsopen(filename.value().c_str(), w_mode.c_str(), _SH_DENYNO);
+ return _wfsopen(ToWCharT(&filename.value()), ToWCharT(&w_mode), _SH_DENYNO);
}
FILE* FileToFILE(File file, const char* mode) {
@@ -592,7 +598,7 @@
}
int ReadFile(const FilePath& filename, char* data, int max_size) {
- win::ScopedHandle file(CreateFile(filename.value().c_str(), GENERIC_READ,
+ win::ScopedHandle file(CreateFile(ToWCharT(&filename.value()), GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN,
NULL));
@@ -607,9 +613,9 @@
}
int WriteFile(const FilePath& filename, const char* data, int size) {
- win::ScopedHandle file(CreateFile(filename.value().c_str(), GENERIC_WRITE, 0,
- NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
- NULL));
+ win::ScopedHandle file(CreateFile(ToWCharT(&filename.value()), GENERIC_WRITE,
+ 0, NULL, CREATE_ALWAYS,
+ FILE_ATTRIBUTE_NORMAL, NULL));
if (!file.IsValid()) {
DPLOG(WARNING) << "CreateFile failed for path "
<< UTF16ToUTF8(filename.value());
@@ -634,8 +640,9 @@
}
bool AppendToFile(const FilePath& filename, const char* data, int size) {
- win::ScopedHandle file(CreateFile(filename.value().c_str(), FILE_APPEND_DATA,
- 0, NULL, OPEN_EXISTING, 0, NULL));
+ win::ScopedHandle file(CreateFile(ToWCharT(&filename.value()),
+ FILE_APPEND_DATA, 0, NULL, OPEN_EXISTING, 0,
+ NULL));
if (!file.IsValid()) {
return false;
}
@@ -649,33 +656,33 @@
}
bool GetCurrentDirectory(FilePath* dir) {
- wchar_t system_buffer[MAX_PATH];
+ char16_t system_buffer[MAX_PATH];
system_buffer[0] = 0;
- DWORD len = ::GetCurrentDirectory(MAX_PATH, system_buffer);
+ DWORD len = ::GetCurrentDirectory(MAX_PATH, ToWCharT(system_buffer));
if (len == 0 || len > MAX_PATH)
return false;
// TODO(evanm): the old behavior of this function was to always strip the
// trailing slash. We duplicate this here, but it shouldn't be necessary
// when everyone is using the appropriate FilePath APIs.
- std::wstring dir_str(system_buffer);
+ std::u16string dir_str(system_buffer);
*dir = FilePath(dir_str).StripTrailingSeparators();
return true;
}
bool SetCurrentDirectory(const FilePath& directory) {
- return ::SetCurrentDirectory(directory.value().c_str()) != 0;
+ return ::SetCurrentDirectory(ToWCharT(&directory.value())) != 0;
}
int GetMaximumPathComponentLength(const FilePath& path) {
- wchar_t volume_path[MAX_PATH];
- if (!GetVolumePathNameW(path.NormalizePathSeparators().value().c_str(),
- volume_path, arraysize(volume_path))) {
+ char16_t volume_path[MAX_PATH];
+ if (!GetVolumePathNameW(ToWCharT(&path.NormalizePathSeparators().value()),
+ ToWCharT(volume_path), arraysize(volume_path))) {
return -1;
}
DWORD max_length = 0;
- if (!GetVolumeInformationW(volume_path, NULL, 0, NULL, &max_length, NULL,
- NULL, 0)) {
+ if (!GetVolumeInformationW(ToWCharT(volume_path), NULL, 0, NULL, &max_length,
+ NULL, NULL, 0)) {
return -1;
}
diff --git a/base/files/file_win.cc b/base/files/file_win.cc
index 7ca4461..9aae162 100644
--- a/base/files/file_win.cc
+++ b/base/files/file_win.cc
@@ -8,6 +8,7 @@
#include <stdint.h>
#include "base/logging.h"
+#include "base/win/win_util.h"
#include <windows.h>
@@ -348,8 +349,8 @@
if (flags & FLAG_SEQUENTIAL_SCAN)
create_flags |= FILE_FLAG_SEQUENTIAL_SCAN;
- file_.Set(CreateFile(path.value().c_str(), access, sharing, NULL, disposition,
- create_flags, NULL));
+ file_.Set(CreateFile(ToWCharT(&path.value()), access, sharing, NULL,
+ disposition, create_flags, NULL));
if (file_.IsValid()) {
error_details_ = FILE_OK;
diff --git a/base/logging.cc b/base/logging.cc
index c2c243f..1144d61 100644
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -324,7 +324,3 @@
}
} // namespace logging
-
-std::ostream& std::operator<<(std::ostream& out, const wchar_t* wstr) {
- return out << (wstr ? base::WideToUTF8(wstr) : std::string());
-}
diff --git a/base/logging.h b/base/logging.h
index 2edad38..95c96ed 100644
--- a/base/logging.h
+++ b/base/logging.h
@@ -304,13 +304,13 @@
// - Don't cause too much binary bloat.
#if defined(COMPILER_GCC)
-#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL)
+#if defined(ARCH_CPU_X86_FAMILY)
// int 3 will generate a SIGTRAP.
#define TRAP_SEQUENCE() \
asm volatile( \
"int3; ud2; push %0;" ::"i"(static_cast<unsigned char>(__COUNTER__)))
-#elif defined(ARCH_CPU_ARMEL) && !defined(OS_NACL)
+#elif defined(ARCH_CPU_ARMEL)
// bkpt will generate a SIGBUS when running on armv7 and a SIGTRAP when running
// as a 32 bit userspace app on arm64. There doesn't seem to be any way to
// cause a SIGTRAP from userspace without using a syscall (which would be a
@@ -318,7 +318,7 @@
#define TRAP_SEQUENCE() \
asm volatile("bkpt #0; udf %0;" ::"i"(__COUNTER__ % 256))
-#elif defined(ARCH_CPU_ARM64) && !defined(OS_NACL)
+#elif defined(ARCH_CPU_ARM64)
// This will always generate a SIGTRAP on arm64.
#define TRAP_SEQUENCE() \
asm volatile("brk #0; hlt %0;" ::"i"(__COUNTER__ % 65536))
@@ -901,32 +901,11 @@
bool IsLoggingToFileEnabled();
// Returns the default log file path.
-std::wstring GetLogFileFullPath();
+std::u16string GetLogFileFullPath();
#endif
} // namespace logging
-// Note that "The behavior of a C++ program is undefined if it adds declarations
-// or definitions to namespace std or to a namespace within namespace std unless
-// otherwise specified." --C++11[namespace.std]
-//
-// We've checked that this particular definition has the intended behavior on
-// our implementations, but it's prone to breaking in the future, and please
-// don't imitate this in your own definitions without checking with some
-// standard library experts.
-namespace std {
-// These functions are provided as a convenience for logging, which is where we
-// use streams (it is against Google style to use streams in other places). It
-// is designed to allow you to emit non-ASCII Unicode strings to the log file,
-// which is normally ASCII. It is relatively slow, so try not to use it for
-// common cases. Non-ASCII characters will be converted to UTF-8 by these
-// operators.
-std::ostream& operator<<(std::ostream& out, const wchar_t* wstr);
-inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
- return out << wstr.c_str();
-}
-} // namespace std
-
// The NOTIMPLEMENTED() macro annotates codepaths which have not been
// implemented yet. If output spam is a serious concern,
// NOTIMPLEMENTED_LOG_ONCE can be used.
diff --git a/base/numerics/safe_math_shared_impl.h b/base/numerics/safe_math_shared_impl.h
index 583c487..8518b45 100644
--- a/base/numerics/safe_math_shared_impl.h
+++ b/base/numerics/safe_math_shared_impl.h
@@ -18,8 +18,7 @@
#include "base/numerics/safe_conversions.h"
// Where available use builtin math overflow support on Clang and GCC.
-#if !defined(__native_client__) && \
- ((defined(__clang__) && \
+#if ((defined(__clang__) && \
((__clang_major__ > 3) || \
(__clang_major__ == 3 && __clang_minor__ >= 4))) || \
(defined(__GNUC__) && __GNUC__ >= 5))
diff --git a/base/posix/safe_strerror.cc b/base/posix/safe_strerror.cc
index 3e3bb15..252b5df 100644
--- a/base/posix/safe_strerror.cc
+++ b/base/posix/safe_strerror.cc
@@ -20,7 +20,7 @@
namespace base {
-#if defined(__GLIBC__) || defined(OS_NACL)
+#if defined(__GLIBC__)
#define USE_HISTORICAL_STRERRO_R 1
#else
#define USE_HISTORICAL_STRERRO_R 0
diff --git a/base/strings/string16.cc b/base/strings/string16.cc
deleted file mode 100644
index 997ab20..0000000
--- a/base/strings/string16.cc
+++ /dev/null
@@ -1,87 +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.
-
-#include "base/strings/string16.h"
-
-#if defined(WCHAR_T_IS_UTF16) && !defined(_AIX)
-
-#error This file should not be used on 2-byte wchar_t systems
-// If this winds up being needed on 2-byte wchar_t systems, either the
-// definitions below can be used, or the host system's wide character
-// functions like wmemcmp can be wrapped.
-
-#elif defined(WCHAR_T_IS_UTF32)
-
-#include <ostream>
-
-#include "base/strings/utf_string_conversions.h"
-
-namespace base {
-
-int c16memcmp(const char16* s1, const char16* s2, size_t n) {
- // We cannot call memcmp because that changes the semantics.
- while (n-- > 0) {
- if (*s1 != *s2) {
- // We cannot use (*s1 - *s2) because char16 is unsigned.
- return ((*s1 < *s2) ? -1 : 1);
- }
- ++s1;
- ++s2;
- }
- return 0;
-}
-
-size_t c16len(const char16* s) {
- const char16* s_orig = s;
- while (*s) {
- ++s;
- }
- return s - s_orig;
-}
-
-const char16* c16memchr(const char16* s, char16 c, size_t n) {
- while (n-- > 0) {
- if (*s == c) {
- return s;
- }
- ++s;
- }
- return nullptr;
-}
-
-char16* c16memmove(char16* s1, const char16* s2, size_t n) {
- return static_cast<char16*>(memmove(s1, s2, n * sizeof(char16)));
-}
-
-char16* c16memcpy(char16* s1, const char16* s2, size_t n) {
- return static_cast<char16*>(memcpy(s1, s2, n * sizeof(char16)));
-}
-
-char16* c16memset(char16* s, char16 c, size_t n) {
- char16* s_orig = s;
- while (n-- > 0) {
- *s = c;
- ++s;
- }
- return s_orig;
-}
-
-namespace string16_internals {
-
-std::ostream& operator<<(std::ostream& out, const string16& str) {
- return out << UTF16ToUTF8(str);
-}
-
-void PrintTo(const string16& str, std::ostream* out) {
- *out << str;
-}
-
-} // namespace string16_internals
-
-} // namespace base
-
-template class std::
- basic_string<base::char16, base::string16_internals::string16_char_traits>;
-
-#endif // WCHAR_T_IS_UTF32
diff --git a/base/strings/string16.h b/base/strings/string16.h
index 59bf6d7..a8e6ae3 100644
--- a/base/strings/string16.h
+++ b/base/strings/string16.h
@@ -5,199 +5,15 @@
#ifndef BASE_STRINGS_STRING16_H_
#define BASE_STRINGS_STRING16_H_
-// WHAT:
-// A version of std::basic_string that provides 2-byte characters even when
-// wchar_t is not implemented as a 2-byte type. You can access this class as
-// string16. We also define char16, which string16 is based upon.
-//
-// WHY:
-// On Windows, wchar_t is 2 bytes, and it can conveniently handle UTF-16/UCS-2
-// data. Plenty of existing code operates on strings encoded as UTF-16.
-//
-// On many other platforms, sizeof(wchar_t) is 4 bytes by default. We can make
-// it 2 bytes by using the GCC flag -fshort-wchar. But then std::wstring fails
-// at run time, because it calls some functions (like wcslen) that come from
-// the system's native C library -- which was built with a 4-byte wchar_t!
-// It's wasteful to use 4-byte wchar_t strings to carry UTF-16 data, and it's
-// entirely improper on those systems where the encoding of wchar_t is defined
-// as UTF-32.
-//
-// Here, we define string16, which is similar to std::wstring but replaces all
-// libc functions with custom, 2-byte-char compatible routines. It is capable
-// of carrying UTF-16-encoded data.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include <functional>
#include <string>
-#include "util/build_config.h"
-
-#if defined(WCHAR_T_IS_UTF16)
-
namespace base {
-typedef wchar_t char16;
-typedef std::wstring string16;
+// Temporary definitions. These should be removed and code using the standard
+// ones.
+using char16 = char16_t;
+using string16 = std::u16string;
} // namespace base
-#elif defined(WCHAR_T_IS_UTF32)
-
-#include <wchar.h> // for mbstate_t
-
-namespace base {
-
-typedef uint16_t char16;
-
-// char16 versions of the functions required by string16_char_traits; these
-// are based on the wide character functions of similar names ("w" or "wcs"
-// instead of "c16").
-int c16memcmp(const char16* s1, const char16* s2, size_t n);
-size_t c16len(const char16* s);
-const char16* c16memchr(const char16* s, char16 c, size_t n);
-char16* c16memmove(char16* s1, const char16* s2, size_t n);
-char16* c16memcpy(char16* s1, const char16* s2, size_t n);
-char16* c16memset(char16* s, char16 c, size_t n);
-
-// This namespace contains the implementation of base::string16 along with
-// things that need to be found via argument-dependent lookup from a
-// base::string16.
-namespace string16_internals {
-
-struct string16_char_traits {
- typedef char16 char_type;
- typedef int int_type;
-
- // int_type needs to be able to hold each possible value of char_type, and in
- // addition, the distinct value of eof().
- static_assert(sizeof(int_type) > sizeof(char_type),
- "int must be larger than 16 bits wide");
-
- typedef std::streamoff off_type;
- typedef mbstate_t state_type;
- typedef std::fpos<state_type> pos_type;
-
- static void assign(char_type& c1, const char_type& c2) { c1 = c2; }
-
- static bool eq(const char_type& c1, const char_type& c2) { return c1 == c2; }
- static bool lt(const char_type& c1, const char_type& c2) { return c1 < c2; }
-
- static int compare(const char_type* s1, const char_type* s2, size_t n) {
- return c16memcmp(s1, s2, n);
- }
-
- static size_t length(const char_type* s) { return c16len(s); }
-
- static const char_type* find(const char_type* s,
- size_t n,
- const char_type& a) {
- return c16memchr(s, a, n);
- }
-
- static char_type* move(char_type* s1, const char_type* s2, size_t n) {
- return c16memmove(s1, s2, n);
- }
-
- static char_type* copy(char_type* s1, const char_type* s2, size_t n) {
- return c16memcpy(s1, s2, n);
- }
-
- static char_type* assign(char_type* s, size_t n, char_type a) {
- return c16memset(s, a, n);
- }
-
- static int_type not_eof(const int_type& c) {
- return eq_int_type(c, eof()) ? 0 : c;
- }
-
- static char_type to_char_type(const int_type& c) { return char_type(c); }
-
- static int_type to_int_type(const char_type& c) { return int_type(c); }
-
- static bool eq_int_type(const int_type& c1, const int_type& c2) {
- return c1 == c2;
- }
-
- static int_type eof() { return static_cast<int_type>(EOF); }
-};
-
-} // namespace string16_internals
-
-typedef std::basic_string<char16,
- base::string16_internals::string16_char_traits>
- string16;
-
-namespace string16_internals {
-
-extern std::ostream& operator<<(std::ostream& out, const string16& str);
-
-// This is required by googletest to print a readable output on test failures.
-extern void PrintTo(const string16& str, std::ostream* out);
-
-} // namespace string16_internals
-
-} // namespace base
-
-// The string class will be explicitly instantiated only once, in string16.cc.
-//
-// std::basic_string<> in GNU libstdc++ contains a static data member,
-// _S_empty_rep_storage, to represent empty strings. When an operation such
-// as assignment or destruction is performed on a string, causing its existing
-// data member to be invalidated, it must not be freed if this static data
-// member is being used. Otherwise, it counts as an attempt to free static
-// (and not allocated) data, which is a memory error.
-//
-// Generally, due to C++ template magic, _S_empty_rep_storage will be marked
-// as a coalesced symbol, meaning that the linker will combine multiple
-// instances into a single one when generating output.
-//
-// If a string class is used by multiple shared libraries, a problem occurs.
-// Each library will get its own copy of _S_empty_rep_storage. When strings
-// are passed across a library boundary for alteration or destruction, memory
-// errors will result. GNU libstdc++ contains a configuration option,
-// --enable-fully-dynamic-string (_GLIBCXX_FULLY_DYNAMIC_STRING), which
-// disables the static data member optimization, but it's a good optimization
-// and non-STL code is generally at the mercy of the system's STL
-// configuration. Fully-dynamic strings are not the default for GNU libstdc++
-// libstdc++ itself or for the libstdc++ installations on the systems we care
-// about, such as Mac OS X and relevant flavors of Linux.
-//
-// See also http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24196 .
-//
-// To avoid problems, string classes need to be explicitly instantiated only
-// once, in exactly one library. All other string users see it via an "extern"
-// declaration. This is precisely how GNU libstdc++ handles
-// std::basic_string<char> (string) and std::basic_string<wchar_t> (wstring).
-//
-// This also works around a Mac OS X linker bug in ld64-85.2.1 (Xcode 3.1.2),
-// in which the linker does not fully coalesce symbols when dead code
-// stripping is enabled. This bug causes the memory errors described above
-// to occur even when a std::basic_string<> does not cross shared library
-// boundaries, such as in statically-linked executables.
-//
-// TODO(mark): File this bug with Apple and update this note with a bug number.
-
-extern template class std::
- basic_string<base::char16, base::string16_internals::string16_char_traits>;
-
-// Specialize std::hash for base::string16. Although the style guide forbids
-// this in general, it is necessary for consistency with WCHAR_T_IS_UTF16
-// platforms, where base::string16 is a type alias for std::wstring.
-namespace std {
-template <>
-struct hash<base::string16> {
- std::size_t operator()(const base::string16& s) const {
- std::size_t result = 0;
- for (base::char16 c : s)
- result = (result * 131) + c;
- return result;
- }
-};
-} // namespace std
-
-#endif // WCHAR_T_IS_UTF32
-
#endif // BASE_STRINGS_STRING16_H_
diff --git a/base/strings/string_number_conversions.h b/base/strings/string_number_conversions.h
index ecf950e..8ffdd36 100644
--- a/base/strings/string_number_conversions.h
+++ b/base/strings/string_number_conversions.h
@@ -15,26 +15,6 @@
#include "base/strings/string_piece.h"
#include "util/build_config.h"
-// ----------------------------------------------------------------------------
-// IMPORTANT MESSAGE FROM YOUR SPONSOR
-//
-// This file contains no "wstring" variants. New code should use string16. If
-// you need to make old code work, use the UTF8 version and convert. Please do
-// not add wstring variants.
-//
-// Please do not add "convenience" functions for converting strings to integers
-// that return the value and ignore success/failure. That encourages people to
-// write code that doesn't properly handle the error conditions.
-//
-// DO NOT use these functions in any UI unless it's NOT localized on purpose.
-// Instead, use base::MessageFormatter for a complex message with numbers
-// (integer, float) embedded or base::Format{Number,Percent} to
-// just format a single number/percent. Note that some languages use native
-// digits instead of ASCII digits while others use a group separator or decimal
-// point different from ',' and '.'. Using these functions in the UI would lead
-// numbers to be formatted in a non-native way.
-// ----------------------------------------------------------------------------
-
namespace base {
// Number -> string conversions ------------------------------------------------
diff --git a/base/strings/string_piece.h b/base/strings/string_piece.h
index 8e4deae..0722269 100644
--- a/base/strings/string_piece.h
+++ b/base/strings/string_piece.h
@@ -428,11 +428,6 @@
HASH_STRING_PIECE(StringPiece16, sp16);
}
};
-struct WStringPieceHash {
- std::size_t operator()(const WStringPiece& wsp) const {
- HASH_STRING_PIECE(WStringPiece, wsp);
- }
-};
} // namespace base
diff --git a/base/strings/string_piece_forward.h b/base/strings/string_piece_forward.h
index b50b980..86c1d5f 100644
--- a/base/strings/string_piece_forward.h
+++ b/base/strings/string_piece_forward.h
@@ -17,7 +17,6 @@
class BasicStringPiece;
typedef BasicStringPiece<std::string> StringPiece;
typedef BasicStringPiece<string16> StringPiece16;
-typedef BasicStringPiece<std::wstring> WStringPiece;
} // namespace base
diff --git a/base/strings/string_tokenizer.h b/base/strings/string_tokenizer.h
index 451a011..9c3b5fa 100644
--- a/base/strings/string_tokenizer.h
+++ b/base/strings/string_tokenizer.h
@@ -242,7 +242,7 @@
typedef StringTokenizerT<std::string, std::string::const_iterator>
StringTokenizer;
-typedef StringTokenizerT<std::wstring, std::wstring::const_iterator>
+typedef StringTokenizerT<std::u16string, std::u16string::const_iterator>
WStringTokenizer;
typedef StringTokenizerT<std::string, const char*> CStringTokenizer;
diff --git a/base/strings/string_util.cc b/base/strings/string_util.cc
index 9b03c26..f3e8257 100644
--- a/base/strings/string_util.cc
+++ b/base/strings/string_util.cc
@@ -97,54 +97,9 @@
struct NonASCIIMask<8, char> {
static inline uint64_t value() { return 0x8080808080808080ULL; }
};
-#if defined(WCHAR_T_IS_UTF32)
-template <>
-struct NonASCIIMask<4, wchar_t> {
- static inline uint32_t value() { return 0xFFFFFF80U; }
-};
-template <>
-struct NonASCIIMask<8, wchar_t> {
- static inline uint64_t value() { return 0xFFFFFF80FFFFFF80ULL; }
-};
-#endif // WCHAR_T_IS_UTF32
} // namespace
-bool IsWprintfFormatPortable(const wchar_t* format) {
- for (const wchar_t* position = format; *position != '\0'; ++position) {
- if (*position == '%') {
- bool in_specification = true;
- bool modifier_l = false;
- while (in_specification) {
- // Eat up characters until reaching a known specifier.
- if (*++position == '\0') {
- // The format string ended in the middle of a specification. Call
- // it portable because no unportable specifications were found. The
- // string is equally broken on all platforms.
- return true;
- }
-
- if (*position == 'l') {
- // 'l' is the only thing that can save the 's' and 'c' specifiers.
- modifier_l = true;
- } else if (((*position == 's' || *position == 'c') && !modifier_l) ||
- *position == 'S' || *position == 'C' || *position == 'F' ||
- *position == 'D' || *position == 'O' || *position == 'U') {
- // Not portable.
- return false;
- }
-
- if (wcschr(L"diouxXeEfgGaAcspn%", *position)) {
- // Portable, keep scanning the rest of the format string.
- in_specification = false;
- }
- }
- }
- }
-
- return true;
-}
-
namespace {
template <typename StringType>
@@ -489,12 +444,6 @@
return DoIsStringASCII(str.data(), str.length());
}
-#if defined(WCHAR_T_IS_UTF32)
-bool IsStringASCII(WStringPiece str) {
- return DoIsStringASCII(str.data(), str.length());
-}
-#endif
-
bool IsStringUTF8(StringPiece str) {
const char* src = str.data();
int32_t src_len = static_cast<int32_t>(str.length());
@@ -623,7 +572,7 @@
return EndsWithT<string16>(str, search_for, case_sensitivity);
}
-char HexDigitToInt(wchar_t c) {
+char HexDigitToInt(char16_t c) {
DCHECK(IsHexDigit(c));
if (c >= '0' && c <= '9')
return static_cast<char>(c - '0');
@@ -634,9 +583,9 @@
return 0;
}
-bool IsUnicodeWhitespace(wchar_t c) {
+bool IsUnicodeWhitespace(char16_t c) {
// kWhitespaceWide is a NULL-terminated string
- for (const wchar_t* cur = kWhitespaceWide; *cur; ++cur) {
+ for (const char16_t* cur = kWhitespaceUTF16; *cur; ++cur) {
if (*cur == c)
return true;
}
@@ -1091,11 +1040,4 @@
} // namespace
-size_t strlcpy(char* dst, const char* src, size_t dst_size) {
- return lcpyT<char>(dst, src, dst_size);
-}
-size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
- return lcpyT<wchar_t>(dst, src, dst_size);
-}
-
} // namespace base
diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index 2d5d01c..9b3c608 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -53,38 +53,6 @@
return result;
}
-// BSD-style safe and consistent string copy functions.
-// Copies |src| to |dst|, where |dst_size| is the total allocated size of |dst|.
-// Copies at most |dst_size|-1 characters, and always NULL terminates |dst|, as
-// long as |dst_size| is not 0. Returns the length of |src| in characters.
-// If the return value is >= dst_size, then the output was truncated.
-// NOTE: All sizes are in number of characters, NOT in bytes.
-size_t strlcpy(char* dst, const char* src, size_t dst_size);
-size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size);
-
-// Scan a wprintf format string to determine whether it's portable across a
-// variety of systems. This function only checks that the conversion
-// specifiers used by the format string are supported and have the same meaning
-// on a variety of systems. It doesn't check for other errors that might occur
-// within a format string.
-//
-// Nonportable conversion specifiers for wprintf are:
-// - 's' and 'c' without an 'l' length modifier. %s and %c operate on char
-// data on all systems except Windows, which treat them as wchar_t data.
-// Use %ls and %lc for wchar_t data instead.
-// - 'S' and 'C', which operate on wchar_t data on all systems except Windows,
-// which treat them as char data. Use %ls and %lc for wchar_t data
-// instead.
-// - 'F', which is not identified by Windows wprintf documentation.
-// - 'D', 'O', and 'U', which are deprecated and not available on all systems.
-// Use %ld, %lo, and %lu instead.
-//
-// Note that there is no portable conversion specifier for char data when
-// working with wprintf.
-//
-// This function is intended to be called from base::vswprintf.
-bool IsWprintfFormatPortable(const wchar_t* format);
-
// ASCII-specific tolower. The standard library's tolower is locale sensitive,
// so we don't want to use it here.
inline char ToLowerASCII(char c) {
@@ -146,7 +114,6 @@
// 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 wchar_t kWhitespaceWide[]; // Includes Unicode.
extern const char16 kWhitespaceUTF16[]; // Includes Unicode.
extern const char kWhitespaceASCII[];
extern const char16 kWhitespaceASCIIAs16[]; // No unicode.
@@ -264,9 +231,6 @@
bool IsStringUTF8(StringPiece str);
bool IsStringASCII(StringPiece str);
bool IsStringASCII(StringPiece16 str);
-#if defined(WCHAR_T_IS_UTF32)
-bool IsStringASCII(WStringPiece str);
-#endif
// Compare the lower-case form of the given string against the given
// previously-lower-cased ASCII string (typically a constant).
@@ -338,10 +302,10 @@
// 'a' -> 10
// 'B' -> 11
// Assumes the input is a valid hex character. DCHECKs in debug builds if not.
-char HexDigitToInt(wchar_t c);
+char HexDigitToInt(char16_t c);
// Returns true if it's a Unicode whitespace character.
-bool IsUnicodeWhitespace(wchar_t c);
+bool IsUnicodeWhitespace(char16_t c);
// Return a byte string in human-readable format with a unit suffix. Not
// appropriate for use in any UI; use of FormatBytes and friends in ui/base is
diff --git a/base/strings/string_util_constants.cc b/base/strings/string_util_constants.cc
index 37ff95f..ed17fcd 100644
--- a/base/strings/string_util_constants.cc
+++ b/base/strings/string_util_constants.cc
@@ -34,8 +34,6 @@
0x3000, /* IDEOGRAPHIC SPACE */ \
0
-const wchar_t kWhitespaceWide[] = {WHITESPACE_UNICODE};
-
const char16 kWhitespaceUTF16[] = {WHITESPACE_UNICODE};
const char kWhitespaceASCII[] = {0x09, // CHARACTER TABULATION
diff --git a/base/strings/string_util_posix.h b/base/strings/string_util_posix.h
index 6868a65..83be1db 100644
--- a/base/strings/string_util_posix.h
+++ b/base/strings/string_util_posix.h
@@ -7,20 +7,12 @@
#include <stdarg.h>
#include <stddef.h>
-#include <stdio.h>
#include <string.h>
-#include <wchar.h>
#include "base/logging.h"
namespace base {
-// Chromium code style is to not use malloc'd strings; this is only for use
-// for interaction with APIs that require it.
-inline char* strdup(const char* str) {
- return ::strdup(str);
-}
-
inline int vsnprintf(char* buffer,
size_t size,
const char* format,
@@ -28,14 +20,6 @@
return ::vsnprintf(buffer, size, format, arguments);
}
-inline int vswprintf(wchar_t* buffer,
- size_t size,
- const wchar_t* format,
- va_list arguments) {
- DCHECK(IsWprintfFormatPortable(format));
- return ::vswprintf(buffer, size, format, arguments);
-}
-
} // namespace base
#endif // BASE_STRINGS_STRING_UTIL_POSIX_H_
diff --git a/base/strings/string_util_win.h b/base/strings/string_util_win.h
index 8f9fa81..717a72c 100644
--- a/base/strings/string_util_win.h
+++ b/base/strings/string_util_win.h
@@ -9,18 +9,11 @@
#include <stddef.h>
#include <stdio.h>
#include <string.h>
-#include <wchar.h>
#include "base/logging.h"
namespace base {
-// Chromium code style is to not use malloc'd strings; this is only for use
-// for interaction with APIs that require it.
-inline char* strdup(const char* str) {
- return _strdup(str);
-}
-
inline int vsnprintf(char* buffer,
size_t size,
const char* format,
@@ -31,18 +24,6 @@
return length;
}
-inline int vswprintf(wchar_t* buffer,
- size_t size,
- const wchar_t* format,
- va_list arguments) {
- DCHECK(IsWprintfFormatPortable(format));
-
- int length = _vsnwprintf_s(buffer, size, size - 1, format, arguments);
- if (length < 0)
- return _vscwprintf(format, arguments);
- return length;
-}
-
} // namespace base
#endif // BASE_STRINGS_STRING_UTIL_WIN_H_
diff --git a/base/strings/stringprintf.cc b/base/strings/stringprintf.cc
index c7d141b..20ddfc6 100644
--- a/base/strings/stringprintf.cc
+++ b/base/strings/stringprintf.cc
@@ -32,15 +32,6 @@
return base::vsnprintf(buffer, buf_size, format, argptr);
}
-#if defined(OS_WIN)
-inline int vsnprintfT(wchar_t* buffer,
- size_t buf_size,
- const wchar_t* format,
- va_list argptr) {
- return base::vswprintf(buffer, buf_size, format, argptr);
-}
-#endif
-
// Templatized backend for StringPrintF/StringAppendF. This does not finalize
// the va_list, the caller is expected to do that.
template <class StringType>
@@ -122,17 +113,6 @@
return result;
}
-#if defined(OS_WIN)
-std::wstring StringPrintf(const wchar_t* format, ...) {
- va_list ap;
- va_start(ap, format);
- std::wstring result;
- StringAppendV(&result, format, ap);
- va_end(ap);
- return result;
-}
-#endif
-
std::string StringPrintV(const char* format, va_list ap) {
std::string result;
StringAppendV(&result, format, ap);
@@ -148,19 +128,6 @@
return *dst;
}
-#if defined(OS_WIN)
-const std::wstring& SStringPrintf(std::wstring* dst,
- const wchar_t* format,
- ...) {
- va_list ap;
- va_start(ap, format);
- dst->clear();
- StringAppendV(dst, format, ap);
- va_end(ap);
- return *dst;
-}
-#endif
-
void StringAppendF(std::string* dst, const char* format, ...) {
va_list ap;
va_start(ap, format);
@@ -168,23 +135,8 @@
va_end(ap);
}
-#if defined(OS_WIN)
-void StringAppendF(std::wstring* dst, const wchar_t* format, ...) {
- va_list ap;
- va_start(ap, format);
- StringAppendV(dst, format, ap);
- va_end(ap);
-}
-#endif
-
void StringAppendV(std::string* dst, const char* format, va_list ap) {
StringAppendVT(dst, format, ap);
}
-#if defined(OS_WIN)
-void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap) {
- StringAppendVT(dst, format, ap);
-}
-#endif
-
} // namespace base
diff --git a/base/strings/stringprintf.h b/base/strings/stringprintf.h
index 8c12aca..e6e0746 100644
--- a/base/strings/stringprintf.h
+++ b/base/strings/stringprintf.h
@@ -17,10 +17,6 @@
// Return a C++ string given printf-like input.
std::string StringPrintf(_Printf_format_string_ const char* format, ...)
PRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
-#if defined(OS_WIN)
-std::wstring StringPrintf(_Printf_format_string_ const wchar_t* format, ...)
- WPRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
-#endif
// Return a C++ string given vprintf-like input.
std::string StringPrintV(const char* format, va_list ap)
@@ -30,30 +26,16 @@
const std::string& SStringPrintf(std::string* dst,
_Printf_format_string_ const char* format,
...) PRINTF_FORMAT(2, 3);
-#if defined(OS_WIN)
-const std::wstring& SStringPrintf(std::wstring* dst,
- _Printf_format_string_ const wchar_t* format,
- ...) WPRINTF_FORMAT(2, 3);
-#endif
// Append result to a supplied string.
void StringAppendF(std::string* dst,
_Printf_format_string_ const char* format,
...) PRINTF_FORMAT(2, 3);
-#if defined(OS_WIN)
-void StringAppendF(std::wstring* dst,
- _Printf_format_string_ const wchar_t* format,
- ...) WPRINTF_FORMAT(2, 3);
-#endif
// Lower-level routine that takes a va_list and appends to a specified
// string. All other routines are just convenience wrappers around it.
void StringAppendV(std::string* dst, const char* format, va_list ap)
PRINTF_FORMAT(2, 0);
-#if defined(OS_WIN)
-void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap)
- WPRINTF_FORMAT(2, 0);
-#endif
} // namespace base
diff --git a/base/strings/utf_string_conversion_utils.cc b/base/strings/utf_string_conversion_utils.cc
index c962411..4e5f890 100644
--- a/base/strings/utf_string_conversion_utils.cc
+++ b/base/strings/utf_string_conversion_utils.cc
@@ -53,19 +53,6 @@
return IsValidCodepoint(*code_point);
}
-#if defined(WCHAR_T_IS_UTF32)
-bool ReadUnicodeCharacter(const wchar_t* src,
- int32_t src_len,
- int32_t* char_index,
- uint32_t* code_point) {
- // Conversion is easy since the source is 32-bit.
- *code_point = src[*char_index];
-
- // Validate the value.
- return IsValidCodepoint(*code_point);
-}
-#endif // defined(WCHAR_T_IS_UTF32)
-
// WriteUnicodeCharacter -------------------------------------------------------
size_t WriteUnicodeCharacter(uint32_t code_point, std::string* output) {
@@ -120,10 +107,6 @@
}
// Instantiate versions we know callers will need.
-#if !defined(OS_WIN)
-// wchar_t and char16 are the same thing on Windows.
-template void PrepareForUTF8Output(const wchar_t*, size_t, std::string*);
-#endif
template void PrepareForUTF8Output(const char16*, size_t, std::string*);
template <typename STRING>
@@ -144,10 +127,6 @@
}
// Instantiate versions we know callers will need.
-#if !defined(OS_WIN)
-// std::wstring and string16 are the same thing on Windows.
-template void PrepareForUTF16Or32Output(const char*, size_t, std::wstring*);
-#endif
template void PrepareForUTF16Or32Output(const char*, size_t, string16*);
} // namespace base
diff --git a/base/strings/utf_string_conversion_utils.h b/base/strings/utf_string_conversion_utils.h
index 6f89652..78cbde7 100644
--- a/base/strings/utf_string_conversion_utils.h
+++ b/base/strings/utf_string_conversion_utils.h
@@ -52,14 +52,6 @@
int32_t* char_index,
uint32_t* code_point);
-#if defined(WCHAR_T_IS_UTF32)
-// Reads UTF-32 character. The usage is the same as the 8-bit version above.
-bool ReadUnicodeCharacter(const wchar_t* src,
- int32_t src_len,
- int32_t* char_index,
- uint32_t* code_point);
-#endif // defined(WCHAR_T_IS_UTF32)
-
// WriteUnicodeCharacter -------------------------------------------------------
// Appends a UTF-8 character to the given 8-bit string. Returns the number of
@@ -70,16 +62,6 @@
// string. Returns the number of 16-bit values written.
size_t WriteUnicodeCharacter(uint32_t code_point, string16* output);
-#if defined(WCHAR_T_IS_UTF32)
-// Appends the given UTF-32 character to the given 32-bit string. Returns the
-// number of 32-bit values written.
-inline size_t WriteUnicodeCharacter(uint32_t code_point, std::wstring* output) {
- // This is the easy case, just append the character.
- output->push_back(code_point);
- return 1;
-}
-#endif // defined(WCHAR_T_IS_UTF32)
-
// Generalized Unicode converter -----------------------------------------------
// Guesses the length of the output in UTF-8 in bytes, clears that output
diff --git a/base/strings/utf_string_conversions.cc b/base/strings/utf_string_conversions.cc
index b04d54d..15f12f6 100644
--- a/base/strings/utf_string_conversions.cc
+++ b/base/strings/utf_string_conversions.cc
@@ -37,20 +37,6 @@
static constexpr int value = 3;
};
-#if defined(WCHAR_T_IS_UTF32)
-template <>
-struct SizeCoefficient<wchar_t, char> {
- // UTF-8 uses at most 4 codeunits per character.
- static constexpr int value = 4;
-};
-
-template <>
-struct SizeCoefficient<wchar_t, char16> {
- // UTF-16 uses at most 2 codeunits per character.
- static constexpr int value = 2;
-};
-#endif // defined(WCHAR_T_IS_UTF32)
-
template <typename SrcChar, typename DestChar>
constexpr int size_coefficient_v =
SizeCoefficient<std::decay_t<SrcChar>, std::decay_t<DestChar>>::value;
@@ -67,14 +53,6 @@
CBU16_APPEND_UNSAFE(out, *size, code_point);
}
-#if defined(WCHAR_T_IS_UTF32)
-
-void UnicodeAppendUnsafe(wchar_t* out, int32_t* size, uint32_t code_point) {
- out[(*size)++] = code_point;
-}
-
-#endif // defined(WCHAR_T_IS_UTF32)
-
// DoUTFConversion ------------------------------------------------------------
// Main driver of UTFConversion specialized for different Src encodings.
// dest has to have enough room for the converted text.
@@ -144,31 +122,6 @@
return success;
}
-#if defined(WCHAR_T_IS_UTF32)
-
-template <typename DestChar>
-bool DoUTFConversion(const wchar_t* src,
- int32_t src_len,
- DestChar* dest,
- int32_t* dest_len) {
- bool success = true;
-
- for (int32_t i = 0; i < src_len; ++i) {
- int32_t code_point = src[i];
-
- if (!IsValidCodepoint(code_point)) {
- success = false;
- code_point = kErrorCodePoint;
- }
-
- UnicodeAppendUnsafe(dest, dest_len, code_point);
- }
-
- return success;
-}
-
-#endif // defined(WCHAR_T_IS_UTF32)
-
// UTFConversion --------------------------------------------------------------
// Function template for generating all UTF conversions.
@@ -226,99 +179,7 @@
return ret;
}
-// UTF-16 <-> Wide -------------------------------------------------------------
-
-#if defined(WCHAR_T_IS_UTF16)
-// When wide == UTF-16 the conversions are a NOP.
-
-bool WideToUTF16(const wchar_t* src, size_t src_len, string16* output) {
- output->assign(src, src_len);
- return true;
-}
-
-string16 WideToUTF16(WStringPiece wide) {
- return wide.as_string();
-}
-
-bool UTF16ToWide(const char16* src, size_t src_len, std::wstring* output) {
- output->assign(src, src_len);
- return true;
-}
-
-std::wstring UTF16ToWide(StringPiece16 utf16) {
- return utf16.as_string();
-}
-
-#elif defined(WCHAR_T_IS_UTF32)
-
-bool WideToUTF16(const wchar_t* src, size_t src_len, string16* output) {
- return UTFConversion(base::WStringPiece(src, src_len), output);
-}
-
-string16 WideToUTF16(WStringPiece wide) {
- string16 ret;
- // Ignore the success flag of this call, it will do the best it can for
- // invalid input, which is what we want here.
- WideToUTF16(wide.data(), wide.length(), &ret);
- return ret;
-}
-
-bool UTF16ToWide(const char16* src, size_t src_len, std::wstring* output) {
- return UTFConversion(StringPiece16(src, src_len), output);
-}
-
-std::wstring UTF16ToWide(StringPiece16 utf16) {
- std::wstring ret;
- // Ignore the success flag of this call, it will do the best it can for
- // invalid input, which is what we want here.
- UTF16ToWide(utf16.data(), utf16.length(), &ret);
- return ret;
-}
-
-#endif // defined(WCHAR_T_IS_UTF32)
-
-// UTF-8 <-> Wide --------------------------------------------------------------
-
-// UTF8ToWide is the same code, regardless of whether wide is 16 or 32 bits
-
-bool UTF8ToWide(const char* src, size_t src_len, std::wstring* output) {
- return UTFConversion(StringPiece(src, src_len), output);
-}
-
-std::wstring UTF8ToWide(StringPiece utf8) {
- std::wstring ret;
- // Ignore the success flag of this call, it will do the best it can for
- // invalid input, which is what we want here.
- UTF8ToWide(utf8.data(), utf8.length(), &ret);
- return ret;
-}
-
-#if defined(WCHAR_T_IS_UTF16)
-// Easy case since we can use the "utf" versions we already wrote above.
-
-bool WideToUTF8(const wchar_t* src, size_t src_len, std::string* output) {
- return UTF16ToUTF8(src, src_len, output);
-}
-
-std::string WideToUTF8(WStringPiece wide) {
- return UTF16ToUTF8(wide);
-}
-
-#elif defined(WCHAR_T_IS_UTF32)
-
-bool WideToUTF8(const wchar_t* src, size_t src_len, std::string* output) {
- return UTFConversion(WStringPiece(src, src_len), output);
-}
-
-std::string WideToUTF8(WStringPiece wide) {
- 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.
- WideToUTF8(wide.data(), wide.length(), &ret);
- return ret;
-}
-
-#endif // defined(WCHAR_T_IS_UTF32)
+// ASCII <-> UTF-16 -----------------------------------------------------------
string16 ASCIIToUTF16(StringPiece ascii) {
DCHECK(IsStringASCII(ascii)) << ascii;
diff --git a/base/strings/utf_string_conversions.h b/base/strings/utf_string_conversions.h
index 704943e..c4c2b11 100644
--- a/base/strings/utf_string_conversions.h
+++ b/base/strings/utf_string_conversions.h
@@ -14,22 +14,6 @@
namespace base {
-// These convert between UTF-8, -16, and -32 strings. They are potentially slow,
-// so avoid unnecessary conversions. The low-level versions return a boolean
-// indicating whether the conversion was 100% valid. In this case, it will still
-// do the best it can and put the result in the output buffer. The versions that
-// return strings ignore this error and just return the best conversion
-// possible.
-bool WideToUTF8(const wchar_t* src, size_t src_len, std::string* output);
-std::string WideToUTF8(WStringPiece wide);
-bool UTF8ToWide(const char* src, size_t src_len, std::wstring* output);
-std::wstring UTF8ToWide(StringPiece utf8);
-
-bool WideToUTF16(const wchar_t* src, size_t src_len, string16* output);
-string16 WideToUTF16(WStringPiece wide);
-bool UTF16ToWide(const char16* src, size_t src_len, std::wstring* output);
-std::wstring UTF16ToWide(StringPiece16 utf16);
-
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);
diff --git a/base/win/registry.cc b/base/win/registry.cc
index e07820b..2ea2de3 100644
--- a/base/win/registry.cc
+++ b/base/win/registry.cc
@@ -11,6 +11,7 @@
#include "base/logging.h"
#include "base/macros.h"
#include "base/strings/string_util.h"
+#include "base/win/win_util.h"
namespace base {
namespace win {
@@ -22,11 +23,11 @@
// name size, such that a buffer with this size should read any name.
const DWORD MAX_REGISTRY_NAME_SIZE = 16384;
-// Registry values are read as BYTE* but can have wchar_t* data whose last
-// wchar_t is truncated. This function converts the reported |byte_size| to
-// a size in wchar_t that can store a truncated wchar_t if necessary.
+// Registry values are read as BYTE* but can have char16_t* data whose last
+// char16_t is truncated. This function converts the reported |byte_size| to
+// a size in char16_t that can store a truncated char16_t if necessary.
inline DWORD to_wchar_size(DWORD byte_size) {
- return (byte_size + sizeof(wchar_t) - 1) / sizeof(wchar_t);
+ return (byte_size + sizeof(char16_t) - 1) / sizeof(char16_t);
}
// Mask to pull WOW64 access flags out of REGSAM access.
@@ -40,7 +41,7 @@
RegKey::RegKey(HKEY key) : key_(key), wow64access_(0) {}
-RegKey::RegKey(HKEY rootkey, const wchar_t* subkey, REGSAM access)
+RegKey::RegKey(HKEY rootkey, const char16_t* subkey, REGSAM access)
: key_(NULL), wow64access_(0) {
if (rootkey) {
if (access & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_CREATE_LINK))
@@ -57,20 +58,20 @@
Close();
}
-LONG RegKey::Create(HKEY rootkey, const wchar_t* subkey, REGSAM access) {
+LONG RegKey::Create(HKEY rootkey, const char16_t* subkey, REGSAM access) {
DWORD disposition_value;
return CreateWithDisposition(rootkey, subkey, &disposition_value, access);
}
LONG RegKey::CreateWithDisposition(HKEY rootkey,
- const wchar_t* subkey,
+ const char16_t* subkey,
DWORD* disposition,
REGSAM access) {
DCHECK(rootkey && subkey && access && disposition);
HKEY subhkey = NULL;
- LONG result =
- RegCreateKeyEx(rootkey, subkey, 0, NULL, REG_OPTION_NON_VOLATILE, access,
- NULL, &subhkey, disposition);
+ LONG result = RegCreateKeyEx(rootkey, ToWCharT(subkey), 0, NULL,
+ REG_OPTION_NON_VOLATILE, access, NULL, &subhkey,
+ disposition);
if (result == ERROR_SUCCESS) {
Close();
key_ = subhkey;
@@ -80,7 +81,7 @@
return result;
}
-LONG RegKey::CreateKey(const wchar_t* name, REGSAM access) {
+LONG RegKey::CreateKey(const char16_t* name, REGSAM access) {
DCHECK(name && access);
// After the application has accessed an alternate registry view using one of
// the [KEY_WOW64_32KEY / KEY_WOW64_64KEY] flags, all subsequent operations
@@ -92,8 +93,9 @@
return ERROR_INVALID_PARAMETER;
}
HKEY subkey = NULL;
- LONG result = RegCreateKeyEx(key_, name, 0, NULL, REG_OPTION_NON_VOLATILE,
- access, NULL, &subkey, NULL);
+ LONG result =
+ RegCreateKeyEx(key_, ToWCharT(name), 0, NULL, REG_OPTION_NON_VOLATILE,
+ access, NULL, &subkey, NULL);
if (result == ERROR_SUCCESS) {
Close();
key_ = subkey;
@@ -103,11 +105,11 @@
return result;
}
-LONG RegKey::Open(HKEY rootkey, const wchar_t* subkey, REGSAM access) {
+LONG RegKey::Open(HKEY rootkey, const char16_t* subkey, REGSAM access) {
DCHECK(rootkey && subkey && access);
HKEY subhkey = NULL;
- LONG result = RegOpenKeyEx(rootkey, subkey, 0, access, &subhkey);
+ LONG result = RegOpenKeyEx(rootkey, ToWCharT(subkey), 0, access, &subhkey);
if (result == ERROR_SUCCESS) {
Close();
key_ = subhkey;
@@ -117,7 +119,7 @@
return result;
}
-LONG RegKey::OpenKey(const wchar_t* relative_key_name, REGSAM access) {
+LONG RegKey::OpenKey(const char16_t* relative_key_name, REGSAM access) {
DCHECK(relative_key_name && access);
// After the application has accessed an alternate registry view using one of
// the [KEY_WOW64_32KEY / KEY_WOW64_64KEY] flags, all subsequent operations
@@ -129,7 +131,8 @@
return ERROR_INVALID_PARAMETER;
}
HKEY subkey = NULL;
- LONG result = RegOpenKeyEx(key_, relative_key_name, 0, access, &subkey);
+ LONG result =
+ RegOpenKeyEx(key_, ToWCharT(relative_key_name), 0, access, &subkey);
// We have to close the current opened key before replacing it with the new
// one.
@@ -164,8 +167,9 @@
return key;
}
-bool RegKey::HasValue(const wchar_t* name) const {
- return RegQueryValueEx(key_, name, 0, NULL, NULL, NULL) == ERROR_SUCCESS;
+bool RegKey::HasValue(const char16_t* name) const {
+ return RegQueryValueEx(key_, ToWCharT(name), 0, NULL, NULL, NULL) ==
+ ERROR_SUCCESS;
}
DWORD RegKey::GetValueCount() const {
@@ -175,39 +179,40 @@
return (result == ERROR_SUCCESS) ? count : 0;
}
-LONG RegKey::GetValueNameAt(int index, std::wstring* name) const {
- wchar_t buf[256];
+LONG RegKey::GetValueNameAt(int index, std::u16string* name) const {
+ char16_t buf[256];
DWORD bufsize = arraysize(buf);
- LONG r = ::RegEnumValue(key_, index, buf, &bufsize, NULL, NULL, NULL, NULL);
+ LONG r = ::RegEnumValue(key_, index, ToWCharT(buf), &bufsize, NULL, NULL,
+ NULL, NULL);
if (r == ERROR_SUCCESS)
*name = buf;
return r;
}
-LONG RegKey::DeleteKey(const wchar_t* name) {
+LONG RegKey::DeleteKey(const char16_t* name) {
DCHECK(key_);
DCHECK(name);
HKEY subkey = NULL;
// Verify the key exists before attempting delete to replicate previous
// behavior.
- LONG result =
- RegOpenKeyEx(key_, name, 0, READ_CONTROL | wow64access_, &subkey);
+ LONG result = RegOpenKeyEx(key_, ToWCharT(name), 0,
+ READ_CONTROL | wow64access_, &subkey);
if (result != ERROR_SUCCESS)
return result;
RegCloseKey(subkey);
- return RegDelRecurse(key_, std::wstring(name), wow64access_);
+ return RegDelRecurse(key_, std::u16string(name), wow64access_);
}
-LONG RegKey::DeleteEmptyKey(const wchar_t* name) {
+LONG RegKey::DeleteEmptyKey(const char16_t* name) {
DCHECK(key_);
DCHECK(name);
HKEY target_key = NULL;
- LONG result =
- RegOpenKeyEx(key_, name, 0, KEY_READ | wow64access_, &target_key);
+ LONG result = RegOpenKeyEx(key_, ToWCharT(name), 0, KEY_READ | wow64access_,
+ &target_key);
if (result != ERROR_SUCCESS)
return result;
@@ -227,13 +232,13 @@
return ERROR_DIR_NOT_EMPTY;
}
-LONG RegKey::DeleteValue(const wchar_t* value_name) {
+LONG RegKey::DeleteValue(const char16_t* value_name) {
DCHECK(key_);
- LONG result = RegDeleteValue(key_, value_name);
+ LONG result = RegDeleteValue(key_, ToWCharT(value_name));
return result;
}
-LONG RegKey::ReadValueDW(const wchar_t* name, DWORD* out_value) const {
+LONG RegKey::ReadValueDW(const char16_t* name, DWORD* out_value) const {
DCHECK(out_value);
DWORD type = REG_DWORD;
DWORD size = sizeof(DWORD);
@@ -249,7 +254,7 @@
return result;
}
-LONG RegKey::ReadInt64(const wchar_t* name, int64_t* out_value) const {
+LONG RegKey::ReadInt64(const char16_t* name, int64_t* out_value) const {
DCHECK(out_value);
DWORD type = REG_QWORD;
int64_t local_value = 0;
@@ -266,20 +271,21 @@
return result;
}
-LONG RegKey::ReadValue(const wchar_t* name, std::wstring* out_value) const {
+LONG RegKey::ReadValue(const char16_t* name, std::u16string* out_value) const {
DCHECK(out_value);
const size_t kMaxStringLength = 1024; // This is after expansion.
// Use the one of the other forms of ReadValue if 1024 is too small for you.
- wchar_t raw_value[kMaxStringLength];
+ char16_t raw_value[kMaxStringLength];
DWORD type = REG_SZ, size = sizeof(raw_value);
LONG result = ReadValue(name, raw_value, &size, &type);
if (result == ERROR_SUCCESS) {
if (type == REG_SZ) {
*out_value = raw_value;
} else if (type == REG_EXPAND_SZ) {
- wchar_t expanded[kMaxStringLength];
- size = ExpandEnvironmentStrings(raw_value, expanded, kMaxStringLength);
- // Success: returns the number of wchar_t's copied
+ char16_t expanded[kMaxStringLength];
+ size = ExpandEnvironmentStrings(ToWCharT(raw_value), ToWCharT(expanded),
+ kMaxStringLength);
+ // Success: returns the number of char16_t's copied
// Fail: buffer too small, returns the size required
// Fail: other, returns 0
if (size == 0 || size > kMaxStringLength) {
@@ -296,17 +302,17 @@
return result;
}
-LONG RegKey::ReadValue(const wchar_t* name,
+LONG RegKey::ReadValue(const char16_t* name,
void* data,
DWORD* dsize,
DWORD* dtype) const {
- LONG result = RegQueryValueEx(key_, name, 0, dtype,
+ LONG result = RegQueryValueEx(key_, ToWCharT(name), 0, dtype,
reinterpret_cast<LPBYTE>(data), dsize);
return result;
}
-LONG RegKey::ReadValues(const wchar_t* name,
- std::vector<std::wstring>* values) {
+LONG RegKey::ReadValues(const char16_t* name,
+ std::vector<std::u16string>* values) {
values->clear();
DWORD type = REG_MULTI_SZ;
@@ -318,7 +324,7 @@
if (type != REG_MULTI_SZ)
return ERROR_CANTREAD;
- std::vector<wchar_t> buffer(size / sizeof(wchar_t));
+ std::vector<char16_t> buffer(size / sizeof(char16_t));
result = ReadValue(name, &buffer[0], &size, NULL);
if (result != ERROR_SUCCESS || size == 0)
return result;
@@ -326,42 +332,43 @@
// Parse the double-null-terminated list of strings.
// Note: This code is paranoid to not read outside of |buf|, in the case where
// it may not be properly terminated.
- const wchar_t* entry = &buffer[0];
- const wchar_t* buffer_end = entry + (size / sizeof(wchar_t));
+ const char16_t* entry = &buffer[0];
+ const char16_t* buffer_end = entry + (size / sizeof(char16_t));
while (entry < buffer_end && entry[0] != '\0') {
- const wchar_t* entry_end = std::find(entry, buffer_end, L'\0');
- values->push_back(std::wstring(entry, entry_end));
+ const char16_t* entry_end = std::find(entry, buffer_end, L'\0');
+ values->push_back(std::u16string(entry, entry_end));
entry = entry_end + 1;
}
return 0;
}
-LONG RegKey::WriteValue(const wchar_t* name, DWORD in_value) {
+LONG RegKey::WriteValue(const char16_t* name, DWORD in_value) {
return WriteValue(name, &in_value, static_cast<DWORD>(sizeof(in_value)),
REG_DWORD);
}
-LONG RegKey::WriteValue(const wchar_t* name, const wchar_t* in_value) {
+LONG RegKey::WriteValue(const char16_t* name, const char16_t* in_value) {
return WriteValue(
name, in_value,
- static_cast<DWORD>(sizeof(*in_value) * (wcslen(in_value) + 1)), REG_SZ);
+ static_cast<DWORD>(sizeof(*in_value) * (wcslen(ToWCharT(in_value)) + 1)),
+ REG_SZ);
}
-LONG RegKey::WriteValue(const wchar_t* name,
+LONG RegKey::WriteValue(const char16_t* name,
const void* data,
DWORD dsize,
DWORD dtype) {
DCHECK(data || !dsize);
LONG result =
- RegSetValueEx(key_, name, 0, dtype,
+ RegSetValueEx(key_, ToWCharT(name), 0, dtype,
reinterpret_cast<LPBYTE>(const_cast<void*>(data)), dsize);
return result;
}
// static
LONG RegKey::RegDeleteKeyExWrapper(HKEY hKey,
- const wchar_t* lpSubKey,
+ const char16_t* lpSubKey,
REGSAM samDesired,
DWORD Reserved) {
typedef LSTATUS(WINAPI * RegDeleteKeyExPtr)(HKEY, LPCWSTR, REGSAM, DWORD);
@@ -371,15 +378,16 @@
GetProcAddress(GetModuleHandleA("advapi32.dll"), "RegDeleteKeyExW"));
if (reg_delete_key_ex_func)
- return reg_delete_key_ex_func(hKey, lpSubKey, samDesired, Reserved);
+ return reg_delete_key_ex_func(hKey, ToWCharT(lpSubKey), samDesired,
+ Reserved);
// Windows XP does not support RegDeleteKeyEx, so fallback to RegDeleteKey.
- return RegDeleteKey(hKey, lpSubKey);
+ return RegDeleteKey(hKey, ToWCharT(lpSubKey));
}
// static
LONG RegKey::RegDelRecurse(HKEY root_key,
- const std::wstring& name,
+ const std::u16string& name,
REGSAM access) {
// First, see if the key can be deleted without having to recurse.
LONG result = RegDeleteKeyExWrapper(root_key, name.c_str(), access, 0);
@@ -387,7 +395,7 @@
return result;
HKEY target_key = NULL;
- result = RegOpenKeyEx(root_key, name.c_str(), 0,
+ result = RegOpenKeyEx(root_key, ToWCharT(&name), 0,
KEY_ENUMERATE_SUB_KEYS | access, &target_key);
if (result == ERROR_FILE_NOT_FOUND)
@@ -395,22 +403,22 @@
if (result != ERROR_SUCCESS)
return result;
- std::wstring subkey_name(name);
+ std::u16string subkey_name(name);
// Check for an ending slash and add one if it is missing.
- if (!name.empty() && subkey_name[name.length() - 1] != L'\\')
- subkey_name += L"\\";
+ if (!name.empty() && subkey_name[name.length() - 1] != '\\')
+ subkey_name += u"\\";
// Enumerate the keys
result = ERROR_SUCCESS;
const DWORD kMaxKeyNameLength = MAX_PATH;
const size_t base_key_length = subkey_name.length();
- std::wstring key_name;
+ std::u16string key_name;
while (result == ERROR_SUCCESS) {
DWORD key_size = kMaxKeyNameLength;
- result =
- RegEnumKeyEx(target_key, 0, WriteInto(&key_name, kMaxKeyNameLength),
- &key_size, NULL, NULL, NULL, NULL);
+ result = RegEnumKeyEx(target_key, 0,
+ ToWCharT(WriteInto(&key_name, kMaxKeyNameLength)),
+ &key_size, NULL, NULL, NULL, NULL);
if (result != ERROR_SUCCESS)
break;
@@ -434,24 +442,24 @@
// RegistryValueIterator ------------------------------------------------------
RegistryValueIterator::RegistryValueIterator(HKEY root_key,
- const wchar_t* folder_key,
+ const char16_t* folder_key,
REGSAM wow64access)
: name_(MAX_PATH, L'\0'), value_(MAX_PATH, L'\0') {
Initialize(root_key, folder_key, wow64access);
}
RegistryValueIterator::RegistryValueIterator(HKEY root_key,
- const wchar_t* folder_key)
+ const char16_t* folder_key)
: name_(MAX_PATH, L'\0'), value_(MAX_PATH, L'\0') {
Initialize(root_key, folder_key, 0);
}
void RegistryValueIterator::Initialize(HKEY root_key,
- const wchar_t* folder_key,
+ const char16_t* folder_key,
REGSAM wow64access) {
DCHECK_EQ(wow64access & ~kWow64AccessMask, static_cast<REGSAM>(0));
- LONG result =
- RegOpenKeyEx(root_key, folder_key, 0, KEY_READ | wow64access, &key_);
+ LONG result = RegOpenKeyEx(root_key, ToWCharT(folder_key), 0,
+ KEY_READ | wow64access, &key_);
if (result != ERROR_SUCCESS) {
key_ = NULL;
} else {
@@ -499,10 +507,10 @@
DWORD capacity = static_cast<DWORD>(name_.capacity());
DWORD name_size = capacity;
// |value_size_| is in bytes. Reserve the last character for a NUL.
- value_size_ = static_cast<DWORD>((value_.size() - 1) * sizeof(wchar_t));
+ value_size_ = static_cast<DWORD>((value_.size() - 1) * sizeof(char16_t));
LONG result = ::RegEnumValue(
- key_, index_, WriteInto(&name_, name_size), &name_size, NULL, &type_,
- reinterpret_cast<BYTE*>(value_.data()), &value_size_);
+ key_, index_, ToWCharT(WriteInto(&name_, name_size)), &name_size, NULL,
+ &type_, reinterpret_cast<BYTE*>(value_.data()), &value_size_);
if (result == ERROR_MORE_DATA) {
// Registry key names are limited to 255 characters and fit within
@@ -514,11 +522,11 @@
DWORD value_size_in_wchars = to_wchar_size(value_size_);
if (value_size_in_wchars + 1 > value_.size())
value_.resize(value_size_in_wchars + 1, L'\0');
- value_size_ = static_cast<DWORD>((value_.size() - 1) * sizeof(wchar_t));
+ value_size_ = static_cast<DWORD>((value_.size() - 1) * sizeof(char16_t));
name_size = name_size == capacity ? MAX_REGISTRY_NAME_SIZE : capacity;
result = ::RegEnumValue(
- key_, index_, WriteInto(&name_, name_size), &name_size, NULL, &type_,
- reinterpret_cast<BYTE*>(value_.data()), &value_size_);
+ key_, index_, ToWCharT(WriteInto(&name_, name_size)), &name_size,
+ NULL, &type_, reinterpret_cast<BYTE*>(value_.data()), &value_size_);
}
if (result == ERROR_SUCCESS) {
@@ -537,12 +545,12 @@
// RegistryKeyIterator --------------------------------------------------------
RegistryKeyIterator::RegistryKeyIterator(HKEY root_key,
- const wchar_t* folder_key) {
+ const char16_t* folder_key) {
Initialize(root_key, folder_key, 0);
}
RegistryKeyIterator::RegistryKeyIterator(HKEY root_key,
- const wchar_t* folder_key,
+ const char16_t* folder_key,
REGSAM wow64access) {
Initialize(root_key, folder_key, wow64access);
}
@@ -575,8 +583,8 @@
if (Valid()) {
DWORD ncount = arraysize(name_);
FILETIME written;
- LONG r = ::RegEnumKeyEx(key_, index_, name_, &ncount, NULL, NULL, NULL,
- &written);
+ LONG r = ::RegEnumKeyEx(key_, index_, ToWCharT(name_), &ncount, NULL, NULL,
+ NULL, &written);
if (ERROR_SUCCESS == r)
return true;
}
@@ -586,11 +594,11 @@
}
void RegistryKeyIterator::Initialize(HKEY root_key,
- const wchar_t* folder_key,
+ const char16_t* folder_key,
REGSAM wow64access) {
DCHECK_EQ(wow64access & ~kWow64AccessMask, static_cast<REGSAM>(0));
- LONG result =
- RegOpenKeyEx(root_key, folder_key, 0, KEY_READ | wow64access, &key_);
+ LONG result = RegOpenKeyEx(root_key, ToWCharT(folder_key), 0,
+ KEY_READ | wow64access, &key_);
if (result != ERROR_SUCCESS) {
key_ = NULL;
} else {
diff --git a/base/win/registry.h b/base/win/registry.h
index e2e0d30..1fb2388 100644
--- a/base/win/registry.h
+++ b/base/win/registry.h
@@ -29,24 +29,24 @@
public:
RegKey();
explicit RegKey(HKEY key);
- RegKey(HKEY rootkey, const wchar_t* subkey, REGSAM access);
+ RegKey(HKEY rootkey, const char16_t* subkey, REGSAM access);
~RegKey();
- LONG Create(HKEY rootkey, const wchar_t* subkey, REGSAM access);
+ LONG Create(HKEY rootkey, const char16_t* subkey, REGSAM access);
LONG CreateWithDisposition(HKEY rootkey,
- const wchar_t* subkey,
+ const char16_t* subkey,
DWORD* disposition,
REGSAM access);
// Creates a subkey or open it if it already exists.
- LONG CreateKey(const wchar_t* name, REGSAM access);
+ LONG CreateKey(const char16_t* name, REGSAM access);
// Opens an existing reg key.
- LONG Open(HKEY rootkey, const wchar_t* subkey, REGSAM access);
+ LONG Open(HKEY rootkey, const char16_t* subkey, REGSAM access);
// Opens an existing reg key, given the relative key name.
- LONG OpenKey(const wchar_t* relative_key_name, REGSAM access);
+ LONG OpenKey(const char16_t* relative_key_name, REGSAM access);
// Closes this reg key.
void Close();
@@ -59,51 +59,51 @@
// Returns false if this key does not have the specified value, or if an error
// occurrs while attempting to access it.
- bool HasValue(const wchar_t* value_name) const;
+ bool HasValue(const char16_t* value_name) const;
// Returns the number of values for this key, or 0 if the number cannot be
// determined.
DWORD GetValueCount() const;
// Determines the nth value's name.
- LONG GetValueNameAt(int index, std::wstring* name) const;
+ LONG GetValueNameAt(int index, std::u16string* name) const;
// True while the key is valid.
bool Valid() const { return key_ != NULL; }
// Kills a key and everything that lives below it; please be careful when
// using it.
- LONG DeleteKey(const wchar_t* name);
+ LONG DeleteKey(const char16_t* name);
// Deletes an empty subkey. If the subkey has subkeys or values then this
// will fail.
- LONG DeleteEmptyKey(const wchar_t* name);
+ LONG DeleteEmptyKey(const char16_t* name);
// Deletes a single value within the key.
- LONG DeleteValue(const wchar_t* name);
+ LONG DeleteValue(const char16_t* name);
// Getters:
// Reads a REG_DWORD (uint32_t) into |out_value|. If |name| is null or empty,
// reads the key's default value, if any.
- LONG ReadValueDW(const wchar_t* name, DWORD* out_value) const;
+ LONG ReadValueDW(const char16_t* name, DWORD* out_value) const;
// Reads a REG_QWORD (int64_t) into |out_value|. If |name| is null or empty,
// reads the key's default value, if any.
- LONG ReadInt64(const wchar_t* name, int64_t* out_value) const;
+ LONG ReadInt64(const char16_t* name, int64_t* out_value) const;
// Reads a string into |out_value|. If |name| is null or empty, reads
// the key's default value, if any.
- LONG ReadValue(const wchar_t* name, std::wstring* out_value) const;
+ LONG ReadValue(const char16_t* name, std::u16string* out_value) const;
// Reads a REG_MULTI_SZ registry field into a vector of strings. Clears
// |values| initially and adds further strings to the list. Returns
// ERROR_CANTREAD if type is not REG_MULTI_SZ.
- LONG ReadValues(const wchar_t* name, std::vector<std::wstring>* values);
+ LONG ReadValues(const char16_t* name, std::vector<std::u16string>* values);
// Reads raw data into |data|. If |name| is null or empty, reads the key's
// default value, if any.
- LONG ReadValue(const wchar_t* name,
+ LONG ReadValue(const char16_t* name,
void* data,
DWORD* dsize,
DWORD* dtype) const;
@@ -111,13 +111,13 @@
// Setters:
// Sets an int32_t value.
- LONG WriteValue(const wchar_t* name, DWORD in_value);
+ LONG WriteValue(const char16_t* name, DWORD in_value);
// Sets a string value.
- LONG WriteValue(const wchar_t* name, const wchar_t* in_value);
+ LONG WriteValue(const char16_t* name, const char16_t* in_value);
// Sets raw data, including type.
- LONG WriteValue(const wchar_t* name,
+ LONG WriteValue(const char16_t* name,
const void* data,
DWORD dsize,
DWORD dtype);
@@ -128,13 +128,13 @@
// Calls RegDeleteKeyEx on supported platforms, alternatively falls back to
// RegDeleteKey.
static LONG RegDeleteKeyExWrapper(HKEY hKey,
- const wchar_t* lpSubKey,
+ const char16_t* lpSubKey,
REGSAM samDesired,
DWORD Reserved);
// Recursively deletes a key and all of its subkeys.
static LONG RegDelRecurse(HKEY root_key,
- const std::wstring& name,
+ const std::u16string& name,
REGSAM access);
HKEY key_; // The registry key being iterated.
@@ -147,7 +147,7 @@
class RegistryValueIterator {
public:
// Constructs a Registry Value Iterator with default WOW64 access.
- RegistryValueIterator(HKEY root_key, const wchar_t* folder_key);
+ RegistryValueIterator(HKEY root_key, const char16_t* folder_key);
// Constructs a Registry Key Iterator with specific WOW64 access, one of
// KEY_WOW64_32KEY or KEY_WOW64_64KEY, or 0.
@@ -155,7 +155,7 @@
// previously, or a predefined key (e.g. HKEY_LOCAL_MACHINE).
// See http://msdn.microsoft.com/en-us/library/windows/desktop/aa384129.aspx.
RegistryValueIterator(HKEY root_key,
- const wchar_t* folder_key,
+ const char16_t* folder_key,
REGSAM wow64access);
~RegistryValueIterator();
@@ -168,8 +168,8 @@
// Advances to the next registry entry.
void operator++();
- const wchar_t* Name() const { return name_.c_str(); }
- const wchar_t* Value() const { return value_.data(); }
+ const char16_t* Name() const { return name_.c_str(); }
+ const char16_t* Value() const { return value_.data(); }
// ValueSize() is in bytes.
DWORD ValueSize() const { return value_size_; }
DWORD Type() const { return type_; }
@@ -180,7 +180,9 @@
// Reads in the current values.
bool Read();
- void Initialize(HKEY root_key, const wchar_t* folder_key, REGSAM wow64access);
+ void Initialize(HKEY root_key,
+ const char16_t* folder_key,
+ REGSAM wow64access);
// The registry key being iterated.
HKEY key_;
@@ -189,8 +191,8 @@
int index_;
// Current values.
- std::wstring name_;
- std::vector<wchar_t> value_;
+ std::u16string name_;
+ std::vector<char16_t> value_;
DWORD value_size_;
DWORD type_;
@@ -200,7 +202,7 @@
class RegistryKeyIterator {
public:
// Constructs a Registry Key Iterator with default WOW64 access.
- RegistryKeyIterator(HKEY root_key, const wchar_t* folder_key);
+ RegistryKeyIterator(HKEY root_key, const char16_t* folder_key);
// Constructs a Registry Value Iterator with specific WOW64 access, one of
// KEY_WOW64_32KEY or KEY_WOW64_64KEY, or 0.
@@ -208,7 +210,7 @@
// previously, or a predefined key (e.g. HKEY_LOCAL_MACHINE).
// See http://msdn.microsoft.com/en-us/library/windows/desktop/aa384129.aspx.
RegistryKeyIterator(HKEY root_key,
- const wchar_t* folder_key,
+ const char16_t* folder_key,
REGSAM wow64access);
~RegistryKeyIterator();
@@ -221,7 +223,7 @@
// Advances to the next entry in the folder.
void operator++();
- const wchar_t* Name() const { return name_; }
+ const char16_t* Name() const { return name_; }
int Index() const { return index_; }
@@ -229,7 +231,9 @@
// Reads in the current values.
bool Read();
- void Initialize(HKEY root_key, const wchar_t* folder_key, REGSAM wow64access);
+ void Initialize(HKEY root_key,
+ const char16_t* folder_key,
+ REGSAM wow64access);
// The registry key being iterated.
HKEY key_;
@@ -237,7 +241,7 @@
// Current index of the iteration.
int index_;
- wchar_t name_[MAX_PATH];
+ char16_t name_[MAX_PATH];
DISALLOW_COPY_AND_ASSIGN(RegistryKeyIterator);
};
diff --git a/base/win/win_util.h b/base/win/win_util.h
new file mode 100644
index 0000000..49eac8a
--- /dev/null
+++ b/base/win/win_util.h
@@ -0,0 +1,30 @@
+// Copyright 2019 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_WIN_WIN_UTIL_H_
+#define BASE_WIN_WIN_UTIL_H_
+
+#include <string>
+#include <string_view>
+
+namespace base {
+
+// Windows API calls take wchar_t but on that platform wchar_t should be the
+// same as a char16_t.
+inline const wchar_t* ToWCharT(const std::u16string* s) {
+ static_assert(sizeof(std::u16string::value_type) == sizeof(wchar_t));
+ return reinterpret_cast<const wchar_t*>(s->c_str());
+}
+
+inline const wchar_t* ToWCharT(const char16_t* s) {
+ return reinterpret_cast<const wchar_t*>(s);
+}
+
+inline wchar_t* ToWCharT(char16_t* s) {
+ return reinterpret_cast<wchar_t*>(s);
+}
+
+} // namespace base
+
+#endif // BASE_WIN_WIN_UTIL_H_
diff --git a/build/gen.py b/build/gen.py
index 4c3f716..3d9406c 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -655,7 +655,6 @@
'base/files/file_util_posix.cc',
'base/posix/file_descriptor_shuffle.cc',
'base/posix/safe_strerror.cc',
- 'base/strings/string16.cc',
])
if platform.is_windows():
diff --git a/tools/gn/command_args.cc b/tools/gn/command_args.cc
index 9957508..096ba8f 100644
--- a/tools/gn/command_args.cc
+++ b/tools/gn/command_args.cc
@@ -288,7 +288,7 @@
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_CLASSNAME;
- info.lpFile = file_to_edit.value().c_str();
+ info.lpFile = reinterpret_cast<LPCWSTR>(file_to_edit.value().c_str());
info.nShow = SW_SHOW;
info.lpClass = L".txt";
if (!::ShellExecuteEx(&info)) {
diff --git a/tools/gn/exec_process.cc b/tools/gn/exec_process.cc
index 6c13558..2496405 100644
--- a/tools/gn/exec_process.cc
+++ b/tools/gn/exec_process.cc
@@ -18,6 +18,7 @@
#include "base/win/scoped_handle.h"
#include "base/win/scoped_process_information.h"
+#include "base/win/win_util.h"
#else
#include <errno.h>
#include <fcntl.h>
@@ -97,11 +98,11 @@
// Create the child process.
PROCESS_INFORMATION temp_process_info = {};
- if (!CreateProcess(nullptr, &cmdline_writable[0], nullptr, nullptr,
- TRUE, // Handles are inherited.
- NORMAL_PRIORITY_CLASS, nullptr,
- startup_dir.value().c_str(), &start_info,
- &temp_process_info)) {
+ if (!CreateProcess(
+ nullptr, base::ToWCharT(&cmdline_writable[0]), nullptr, nullptr,
+ TRUE, // Handles are inherited.
+ NORMAL_PRIORITY_CLASS, nullptr, base::ToWCharT(&startup_dir.value()),
+ &start_info, &temp_process_info)) {
return false;
}
base::win::ScopedProcessInformation proc_info(temp_process_info);
diff --git a/tools/gn/filesystem_utils.cc b/tools/gn/filesystem_utils.cc
index c378233..727e2f3 100644
--- a/tools/gn/filesystem_utils.cc
+++ b/tools/gn/filesystem_utils.cc
@@ -159,8 +159,10 @@
// Note: The documentation for CompareString says it runs fastest on
// null-terminated strings with -1 passed for the length, so we do that here.
// There should not be embedded nulls in filesystem strings.
- return ::CompareString(LOCALE_USER_DEFAULT, LINGUISTIC_IGNORECASE, a.c_str(),
- -1, b.c_str(), -1) == CSTR_EQUAL;
+ return ::CompareString(LOCALE_USER_DEFAULT, LINGUISTIC_IGNORECASE,
+ reinterpret_cast<LPCWSTR>(a.c_str()), -1,
+ reinterpret_cast<LPCWSTR>(b.c_str()),
+ -1) == CSTR_EQUAL;
#else
// Assume case-sensitive filesystems on non-Windows.
return a == b;
@@ -214,7 +216,7 @@
std::string FilePathToUTF8(const base::FilePath::StringType& str) {
#if defined(OS_WIN)
- return base::WideToUTF8(str);
+ return base::UTF16ToUTF8(str);
#else
return str;
#endif
@@ -222,7 +224,7 @@
base::FilePath UTF8ToFilePath(const base::StringPiece& sp) {
#if defined(OS_WIN)
- return base::FilePath(base::UTF8ToWide(sp));
+ return base::FilePath(base::UTF8ToUTF16(sp));
#else
return base::FilePath(sp.as_string());
#endif
@@ -977,9 +979,9 @@
// version opens with FILE_SHARE_READ (normally not what you want when
// replacing the entire contents of the file) which lets us continue even if
// another program has the file open for reading. See http://crbug.com/468437
- base::win::ScopedHandle file(::CreateFile(file_path.value().c_str(),
- GENERIC_WRITE, FILE_SHARE_READ,
- NULL, CREATE_ALWAYS, 0, NULL));
+ base::win::ScopedHandle file(::CreateFile(
+ reinterpret_cast<LPCWSTR>(file_path.value().c_str()), GENERIC_WRITE,
+ FILE_SHARE_READ, NULL, CREATE_ALWAYS, 0, NULL));
if (file.IsValid()) {
DWORD written;
BOOL result = ::WriteFile(file.Get(), data.c_str(), size, &written, NULL);
diff --git a/tools/gn/filesystem_utils_unittest.cc b/tools/gn/filesystem_utils_unittest.cc
index 433ea36..32b30f6 100644
--- a/tools/gn/filesystem_utils_unittest.cc
+++ b/tools/gn/filesystem_utils_unittest.cc
@@ -177,31 +177,31 @@
TEST(FilesystemUtils, MakeAbsoluteFilePathRelativeIfPossible) {
#if defined(OS_WIN)
EXPECT_EQ(
- base::FilePath(L"out\\Debug"),
+ base::FilePath(u"out\\Debug"),
MakeAbsoluteFilePathRelativeIfPossible(
- base::FilePath(L"C:\\src"), base::FilePath(L"C:\\src\\out\\Debug")));
- EXPECT_EQ(base::FilePath(L".\\gn"),
+ base::FilePath(u"C:\\src"), base::FilePath(u"C:\\src\\out\\Debug")));
+ EXPECT_EQ(base::FilePath(u".\\gn"),
MakeAbsoluteFilePathRelativeIfPossible(
- base::FilePath(L"C:\\src\\out\\Debug"),
- base::FilePath(L"C:\\src\\out\\Debug\\gn")));
+ base::FilePath(u"C:\\src\\out\\Debug"),
+ base::FilePath(u"C:\\src\\out\\Debug\\gn")));
EXPECT_EQ(
- base::FilePath(L"..\\.."),
+ base::FilePath(u"..\\.."),
MakeAbsoluteFilePathRelativeIfPossible(
- base::FilePath(L"C:\\src\\out\\Debug"), base::FilePath(L"C:\\src")));
+ base::FilePath(u"C:\\src\\out\\Debug"), base::FilePath(u"C:\\src")));
EXPECT_EQ(
- base::FilePath(L"..\\.."),
+ base::FilePath(u"..\\.."),
MakeAbsoluteFilePathRelativeIfPossible(
- base::FilePath(L"C:\\src\\out\\Debug"), base::FilePath(L"C:/src")));
- EXPECT_EQ(base::FilePath(L"."),
- MakeAbsoluteFilePathRelativeIfPossible(base::FilePath(L"C:\\src"),
- base::FilePath(L"C:\\src")));
- EXPECT_EQ(base::FilePath(L"..\\..\\..\\u\\v\\w"),
+ base::FilePath(u"C:\\src\\out\\Debug"), base::FilePath(u"C:/src")));
+ EXPECT_EQ(base::FilePath(u"."),
+ MakeAbsoluteFilePathRelativeIfPossible(base::FilePath(u"C:\\src"),
+ base::FilePath(u"C:\\src")));
+ EXPECT_EQ(base::FilePath(u"..\\..\\..\\u\\v\\w"),
MakeAbsoluteFilePathRelativeIfPossible(
- base::FilePath(L"C:\\a\\b\\c\\x\\y\\z"),
- base::FilePath(L"C:\\a\\b\\c\\u\\v\\w")));
- EXPECT_EQ(base::FilePath(L"D:\\bar"),
- MakeAbsoluteFilePathRelativeIfPossible(base::FilePath(L"C:\\foo"),
- base::FilePath(L"D:\\bar")));
+ base::FilePath(u"C:\\a\\b\\c\\x\\y\\z"),
+ base::FilePath(u"C:\\a\\b\\c\\u\\v\\w")));
+ EXPECT_EQ(base::FilePath(u"D:\\bar"),
+ MakeAbsoluteFilePathRelativeIfPossible(base::FilePath(u"C:\\foo"),
+ base::FilePath(u"D:\\bar")));
#else
EXPECT_EQ(base::FilePath("out/Debug"),
MakeAbsoluteFilePathRelativeIfPossible(
@@ -559,42 +559,42 @@
TEST(FilesystemUtils, SourceDirForPath) {
#if defined(OS_WIN)
- base::FilePath root(L"C:\\source\\foo\\");
+ base::FilePath root(u"C:\\source\\foo\\");
EXPECT_EQ("/C:/foo/bar/",
- SourceDirForPath(root, base::FilePath(L"C:\\foo\\bar")).value());
- EXPECT_EQ("/", SourceDirForPath(root, base::FilePath(L"/")).value());
+ SourceDirForPath(root, base::FilePath(u"C:\\foo\\bar")).value());
+ EXPECT_EQ("/", SourceDirForPath(root, base::FilePath(u"/")).value());
EXPECT_EQ("//",
- SourceDirForPath(root, base::FilePath(L"C:\\source\\foo")).value());
+ SourceDirForPath(root, base::FilePath(u"C:\\source\\foo")).value());
EXPECT_EQ("//bar/",
- SourceDirForPath(root, base::FilePath(L"C:\\source\\foo\\bar\\"))
+ SourceDirForPath(root, base::FilePath(u"C:\\source\\foo\\bar\\"))
.value());
EXPECT_EQ("//bar/baz/",
- SourceDirForPath(root, base::FilePath(L"C:\\source\\foo\\bar\\baz"))
+ SourceDirForPath(root, base::FilePath(u"C:\\source\\foo\\bar\\baz"))
.value());
// Should be case-and-slash-insensitive.
EXPECT_EQ(
"//baR/",
- SourceDirForPath(root, base::FilePath(L"c:/SOURCE\\Foo/baR/")).value());
+ SourceDirForPath(root, base::FilePath(u"c:/SOURCE\\Foo/baR/")).value());
// Some "weird" Windows paths.
EXPECT_EQ("/foo/bar/",
- SourceDirForPath(root, base::FilePath(L"/foo/bar/")).value());
+ SourceDirForPath(root, base::FilePath(u"/foo/bar/")).value());
EXPECT_EQ("/C:/foo/bar/",
- SourceDirForPath(root, base::FilePath(L"C:foo/bar/")).value());
+ SourceDirForPath(root, base::FilePath(u"C:foo/bar/")).value());
// Also allow absolute GN-style Windows paths.
EXPECT_EQ("/C:/foo/bar/",
- SourceDirForPath(root, base::FilePath(L"/C:/foo/bar")).value());
+ SourceDirForPath(root, base::FilePath(u"/C:/foo/bar")).value());
EXPECT_EQ(
"//bar/",
- SourceDirForPath(root, base::FilePath(L"/C:/source/foo/bar")).value());
+ SourceDirForPath(root, base::FilePath(u"/C:/source/foo/bar")).value());
// Empty source dir.
base::FilePath empty;
EXPECT_EQ(
"/C:/source/foo/",
- SourceDirForPath(empty, base::FilePath(L"C:\\source\\foo")).value());
+ SourceDirForPath(empty, base::FilePath(u"C:\\source\\foo")).value());
#else
base::FilePath root("/source/foo/");
EXPECT_EQ("/foo/bar/",
diff --git a/tools/gn/function_rebase_path_unittest.cc b/tools/gn/function_rebase_path_unittest.cc
index fdd09dc..1bd9b86 100644
--- a/tools/gn/function_rebase_path_unittest.cc
+++ b/tools/gn/function_rebase_path_unittest.cc
@@ -59,7 +59,7 @@
// Test system path output.
#if defined(OS_WIN)
- setup.build_settings()->SetRootPath(base::FilePath(L"C:/path/to/src"));
+ setup.build_settings()->SetRootPath(base::FilePath(u"C:/path/to/src"));
EXPECT_EQ("C:/path/to/src", RebaseOne(scope, ".", "", "//"));
EXPECT_EQ("C:/path/to/src/", RebaseOne(scope, "//", "", "//"));
EXPECT_EQ("C:/path/to/src/foo", RebaseOne(scope, "foo", "", "//"));
@@ -98,7 +98,7 @@
#if defined(OS_WIN)
setup.build_settings()->SetBuildDir(SourceDir("C:/ssd/out/Debug"));
- setup.build_settings()->SetRootPath(base::FilePath(L"C:/hdd/src"));
+ setup.build_settings()->SetRootPath(base::FilePath(u"C:/hdd/src"));
// Test system absolute to-dir.
EXPECT_EQ("../../ssd/out/Debug",
diff --git a/tools/gn/gn_main.cc b/tools/gn/gn_main.cc
index a61a752..8b9f499 100644
--- a/tools/gn/gn_main.cc
+++ b/tools/gn/gn_main.cc
@@ -25,7 +25,7 @@
#if defined(OS_WIN)
std::vector<std::string> out_args;
for (const auto& arg : in_args)
- out_args.push_back(base::WideToUTF8(arg));
+ out_args.push_back(base::UTF16ToUTF8(arg));
return out_args;
#else
return in_args;
diff --git a/tools/gn/label.h b/tools/gn/label.h
index 6606a6b..44f6e40 100644
--- a/tools/gn/label.h
+++ b/tools/gn/label.h
@@ -5,6 +5,8 @@
#ifndef TOOLS_GN_LABEL_H_
#define TOOLS_GN_LABEL_H_
+#include <tuple>
+
#include <stddef.h>
#include "tools/gn/source_dir.h"
diff --git a/tools/gn/ninja_build_writer.cc b/tools/gn/ninja_build_writer.cc
index 3127c9a..c5cd90a 100644
--- a/tools/gn/ninja_build_writer.cc
+++ b/tools/gn/ninja_build_writer.cc
@@ -47,7 +47,7 @@
const Target* last_seen;
};
-} // namespace
+} // namespace
base::CommandLine GetSelfInvocationCommandLine(
const BuildSettings* build_settings) {
@@ -119,10 +119,9 @@
namespace {
std::string GetSelfInvocationCommand(const BuildSettings* build_settings) {
- base::CommandLine cmdline = GetSelfInvocationCommandLine(
- build_settings);
+ base::CommandLine cmdline = GetSelfInvocationCommandLine(build_settings);
#if defined(OS_WIN)
- return base::WideToUTF8(cmdline.GetCommandLineString());
+ return base::UTF16ToUTF8(cmdline.GetCommandLineString());
#else
return cmdline.GetCommandLineString();
#endif
@@ -247,8 +246,8 @@
std::stringstream file;
std::stringstream depfile;
NinjaBuildWriter gen(build_settings, used_toolchains, all_targets,
- default_toolchain, default_toolchain_targets,
- file, depfile);
+ default_toolchain, default_toolchain_targets, file,
+ depfile);
if (!gen.Run(err))
return false;
diff --git a/tools/gn/setup.cc b/tools/gn/setup.cc
index ef26431..1b2ad55 100644
--- a/tools/gn/setup.cc
+++ b/tools/gn/setup.cc
@@ -40,6 +40,7 @@
#include <windows.h>
#include "base/win/scoped_process_information.h"
+#include "base/win/win_util.h"
#endif
const char kDotfile_Help[] =
@@ -192,19 +193,20 @@
#if defined(OS_WIN)
-std::wstring SysMultiByteToWide(base::StringPiece mb) {
+std::u16string SysMultiByteTo16(base::StringPiece mb) {
if (mb.empty())
- return std::wstring();
+ return std::u16string();
int mb_length = static_cast<int>(mb.length());
// Compute the length of the buffer.
int charcount = MultiByteToWideChar(CP_ACP, 0, mb.data(), mb_length, NULL, 0);
if (charcount == 0)
- return std::wstring();
+ return std::u16string();
- std::wstring wide;
+ std::u16string wide;
wide.resize(charcount);
- MultiByteToWideChar(CP_ACP, 0, mb.data(), mb_length, &wide[0], charcount);
+ MultiByteToWideChar(CP_ACP, 0, mb.data(), mb_length, base::ToWCharT(&wide[0]),
+ charcount);
return wide;
}
@@ -220,9 +222,9 @@
// 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 = L"cmd.exe /c \"\"";
+ base::string16 command = u"cmd.exe /c \"\"";
command.append(bat_path.value());
- command.append(L"\" -c \"import sys; print sys.executable\"\"");
+ command.append(u"\" -c \"import sys; print sys.executable\"\"");
std::string python_path;
std::string std_err;
@@ -234,7 +236,7 @@
base::TrimWhitespaceASCII(python_path, base::TRIM_ALL, &python_path);
// Python uses the system multibyte code page for sys.executable.
- base::FilePath exe_path(SysMultiByteToWide(python_path));
+ base::FilePath exe_path(SysMultiByteTo16(python_path));
// Check for reasonable output, cmd may have output an error message.
if (base::PathExists(exe_path))
@@ -243,12 +245,12 @@
return base::FilePath();
}
-const base::char16 kPythonExeName[] = L"python.exe";
-const base::char16 kPythonBatName[] = L"python.bat";
+const base::char16 kPythonExeName[] = u"python.exe";
+const base::char16 kPythonBatName[] = u"python.bat";
base::FilePath FindWindowsPython() {
base::char16 current_directory[MAX_PATH];
- ::GetCurrentDirectory(MAX_PATH, current_directory);
+ ::GetCurrentDirectory(MAX_PATH, reinterpret_cast<LPWSTR>(current_directory));
// First search for python.exe in the current directory.
base::FilePath cur_dir_candidate_exe =
@@ -257,18 +259,20 @@
return cur_dir_candidate_exe;
// Get the path.
- const base::char16 kPathEnvVarName[] = L"Path";
- DWORD path_length = ::GetEnvironmentVariable(kPathEnvVarName, nullptr, 0);
+ const base::char16 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]);
- DWORD actual_path_length =
- ::GetEnvironmentVariable(kPathEnvVarName, full_path.get(), path_length);
+ DWORD actual_path_length = ::GetEnvironmentVariable(
+ reinterpret_cast<LPCWSTR>(kPathEnvVarName),
+ reinterpret_cast<LPWSTR>(full_path.get()), path_length);
CHECK_EQ(path_length, actual_path_length + 1);
// Search for python.exe in the path.
for (const auto& component : base::SplitStringPiece(
- base::StringPiece16(full_path.get(), path_length), L";",
+ base::StringPiece16(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/visual_studio_writer.cc b/tools/gn/visual_studio_writer.cc
index 5f4380c..9d9aa21 100644
--- a/tools/gn/visual_studio_writer.cc
+++ b/tools/gn/visual_studio_writer.cc
@@ -99,8 +99,8 @@
#if defined(OS_WIN)
const base::char16* const subkeys[] = {
- L"SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
- L"SOFTWARE\\Wow6432Node\\Microsoft\\Windows Kits\\Installed Roots"};
+ u"SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
+ u"SOFTWARE\\Wow6432Node\\Microsoft\\Windows Kits\\Installed Roots"};
base::string16 value_name =
base::ASCIIToUTF16("KitsRoot") + base::ASCIIToUTF16(kWindowsKitsVersion);
diff --git a/util/build_config.h b/util/build_config.h
index addd7cf..f98f044 100644
--- a/util/build_config.h
+++ b/util/build_config.h
@@ -5,7 +5,6 @@
// This file adds defines about the platform we're currently building on.
// Operating System:
// OS_WIN / OS_MACOSX / OS_LINUX / OS_POSIX (MACOSX or LINUX) /
-// OS_NACL (NACL_SFI or NACL_NONSFI) / OS_NACL_SFI / OS_NACL_NONSFI
// OS_CHROMEOS is set by the build system
// Compiler:
// COMPILER_MSVC / COMPILER_GCC
@@ -16,19 +15,7 @@
#ifndef BUILD_BUILD_CONFIG_H_
#define BUILD_BUILD_CONFIG_H_
-// A set of macros to use for platform detection.
-#if defined(__native_client__)
-// __native_client__ must be first, so that other OS_ defines are not set.
-#define OS_NACL 1
-// OS_NACL comes in two sandboxing technology flavors, SFI or Non-SFI.
-// PNaCl toolchain defines __native_client_nonsfi__ macro in Non-SFI build
-// mode, while it does not in SFI build mode.
-#if defined(__native_client_nonsfi__)
-#define OS_NACL_NONSFI
-#else
-#define OS_NACL_SFI
-#endif
-#elif defined(ANDROID)
+#if defined(ANDROID)
#define OS_ANDROID 1
#elif defined(__APPLE__)
// only include TargetConditions after testing ANDROID as some android builds
@@ -81,8 +68,8 @@
// more specific macro.
#if defined(OS_AIX) || defined(OS_ANDROID) || defined(OS_ASMJS) || \
defined(OS_FREEBSD) || defined(OS_LINUX) || defined(OS_MACOSX) || \
- defined(OS_NACL) || defined(OS_NETBSD) || defined(OS_OPENBSD) || \
- defined(OS_QNX) || defined(OS_SOLARIS)
+ defined(OS_NETBSD) || defined(OS_OPENBSD) || defined(OS_QNX) || \
+ defined(OS_SOLARIS)
#define OS_POSIX 1
#endif
@@ -176,21 +163,4 @@
#error Please add support for your architecture in build_config.h
#endif
-// Type detection for wchar_t.
-#if defined(OS_WIN)
-#define WCHAR_T_IS_UTF16
-#elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
- (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
-#define WCHAR_T_IS_UTF32
-#elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
- (__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff)
-// On Posix, we'll detect short wchar_t, but projects aren't guaranteed to
-// compile in this mode (in particular, Chrome doesn't). This is intended for
-// other projects using base who manage their own dependencies and make sure
-// short wchar works for them.
-#define WCHAR_T_IS_UTF16
-#else
-#error Please add support for your compiler in build_config.h
-#endif
-
#endif // BUILD_BUILD_CONFIG_H_
diff --git a/util/exe_path.cc b/util/exe_path.cc
index 3c9c9de..4d487fa 100644
--- a/util/exe_path.cc
+++ b/util/exe_path.cc
@@ -13,6 +13,8 @@
#include <mach-o/dyld.h>
#elif defined(OS_WIN)
#include <windows.h>
+
+#include "base/win/win_util.h"
#elif defined(OS_FREEBSD)
#include <limits.h>
#include <sys/sysctl.h>
@@ -42,9 +44,9 @@
#elif defined(OS_WIN)
base::FilePath GetExePath() {
- wchar_t system_buffer[MAX_PATH];
+ char16_t system_buffer[MAX_PATH];
system_buffer[0] = 0;
- if (GetModuleFileName(NULL, system_buffer, MAX_PATH) == 0) {
+ if (GetModuleFileName(NULL, base::ToWCharT(system_buffer), MAX_PATH) == 0) {
return base::FilePath();
}
return base::FilePath(system_buffer);
@@ -53,7 +55,7 @@
#elif defined(OS_FREEBSD)
base::FilePath GetExePath() {
- int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
+ int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
char buf[PATH_MAX];
size_t buf_size = PATH_MAX;
if (sysctl(mib, 4, buf, &buf_size, nullptr, 0) == -1) {
