clang-format everything
Change-Id: I37d07b604fe89b9a893503514ef9dc51347a23c6
Reviewed-on: https://gn-review.googlesource.com/1625
Commit-Queue: Scott Graham <scottmg@chromium.org>
Reviewed-by: Brett Wilson <brettw@chromium.org>
diff --git a/base/bind.h b/base/bind.h
index aab6828..71df0fe 100644
--- a/base/bind.h
+++ b/base/bind.h
@@ -175,8 +175,9 @@
// Bind as OnceCallback.
template <typename Functor, typename... Args>
-inline OnceCallback<MakeUnboundRunType<Functor, Args...>>
-BindOnce(Functor&& functor, Args&&... args) {
+inline OnceCallback<MakeUnboundRunType<Functor, Args...>> BindOnce(
+ Functor&& functor,
+ Args&&... args) {
static_assert(!internal::IsOnceCallback<std::decay_t<Functor>>() ||
(std::is_rvalue_reference<Functor&&>() &&
!std::is_const<std::remove_reference_t<Functor>>()),
@@ -212,14 +213,14 @@
using InvokeFuncStorage = internal::BindStateBase::InvokeFuncStorage;
return CallbackType(new BindState(
reinterpret_cast<InvokeFuncStorage>(invoke_func),
- std::forward<Functor>(functor),
- std::forward<Args>(args)...));
+ std::forward<Functor>(functor), std::forward<Args>(args)...));
}
// Bind as RepeatingCallback.
template <typename Functor, typename... Args>
-inline RepeatingCallback<MakeUnboundRunType<Functor, Args...>>
-BindRepeating(Functor&& functor, Args&&... args) {
+inline RepeatingCallback<MakeUnboundRunType<Functor, Args...>> BindRepeating(
+ Functor&& functor,
+ Args&&... args) {
static_assert(
!internal::IsOnceCallback<std::decay_t<Functor>>(),
"BindRepeating cannot bind OnceCallback. Use BindOnce with std::move().");
@@ -253,16 +254,15 @@
using InvokeFuncStorage = internal::BindStateBase::InvokeFuncStorage;
return CallbackType(new BindState(
reinterpret_cast<InvokeFuncStorage>(invoke_func),
- std::forward<Functor>(functor),
- std::forward<Args>(args)...));
+ std::forward<Functor>(functor), std::forward<Args>(args)...));
}
// Unannotated Bind.
// TODO(tzik): Deprecate this and migrate to OnceCallback and
// RepeatingCallback, once they get ready.
template <typename Functor, typename... Args>
-inline Callback<MakeUnboundRunType<Functor, Args...>>
-Bind(Functor&& functor, Args&&... args) {
+inline Callback<MakeUnboundRunType<Functor, Args...>> Bind(Functor&& functor,
+ Args&&... args) {
return base::BindRepeating(std::forward<Functor>(functor),
std::forward<Args>(args)...);
}
diff --git a/base/callback_internal.cc b/base/callback_internal.cc
index 6cef841..c52d8af 100644
--- a/base/callback_internal.cc
+++ b/base/callback_internal.cc
@@ -23,8 +23,7 @@
BindStateBase::BindStateBase(InvokeFuncStorage polymorphic_invoke,
void (*destructor)(const BindStateBase*))
- : BindStateBase(polymorphic_invoke, destructor, &ReturnFalse) {
-}
+ : BindStateBase(polymorphic_invoke, destructor, &ReturnFalse) {}
BindStateBase::BindStateBase(InvokeFuncStorage polymorphic_invoke,
void (*destructor)(const BindStateBase*),
diff --git a/base/callback_internal.h b/base/callback_internal.h
index 5139e6b..7e5180f 100644
--- a/base/callback_internal.h
+++ b/base/callback_internal.h
@@ -62,7 +62,7 @@
public:
REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
- using InvokeFuncStorage = void(*)();
+ using InvokeFuncStorage = void (*)();
private:
BindStateBase(InvokeFuncStorage polymorphic_invoke,
@@ -84,9 +84,7 @@
friend struct BindState;
friend struct ::base::FakeBindState;
- bool IsCancelled() const {
- return is_cancelled_(this);
- }
+ bool IsCancelled() const { return is_cancelled_(this); }
// In C++, it is safe to cast function pointers to function pointers of
// another type. It is not okay to use void*. We create a InvokeFuncStorage
diff --git a/base/callback_list.h b/base/callback_list.h
index f455c65..cced145 100644
--- a/base/callback_list.h
+++ b/base/callback_list.h
@@ -76,9 +76,7 @@
public:
Subscription(CallbackListBase<CallbackType>* list,
typename std::list<CallbackType>::iterator iter)
- : list_(list),
- iter_(iter) {
- }
+ : list_(list), iter_(iter) {}
~Subscription() {
if (list_->active_iterator_count_) {
@@ -123,14 +121,12 @@
class Iterator {
public:
explicit Iterator(CallbackListBase<CallbackType>* list)
- : list_(list),
- list_iter_(list_->callbacks_.begin()) {
+ : list_(list), list_iter_(list_->callbacks_.begin()) {
++list_->active_iterator_count_;
}
Iterator(const Iterator& iter)
- : list_(iter.list_),
- list_iter_(iter.list_iter_) {
+ : list_(iter.list_), list_iter_(iter.list_iter_) {
++list_->active_iterator_count_;
}
@@ -166,9 +162,7 @@
// Returns an instance of a CallbackListBase::Iterator which can be used
// to run callbacks.
- Iterator GetIterator() {
- return Iterator(this);
- }
+ Iterator GetIterator() { return Iterator(this); }
// Compact the list: remove any entries which were nulled out during
// iteration.
@@ -198,7 +192,8 @@
} // namespace internal
-template <typename Sig> class CallbackList;
+template <typename Sig>
+class CallbackList;
template <typename... Args>
class CallbackList<void(Args...)>
diff --git a/base/command_line.cc b/base/command_line.cc
index 134ffb8..a49ca71 100644
--- a/base/command_line.cc
+++ b/base/command_line.cc
@@ -19,6 +19,7 @@
#if defined(OS_WIN)
#include <windows.h>
+
#include <shellapi.h>
#endif
@@ -123,7 +124,8 @@
if (arg[i] == '\\') {
// Find the extent of this run of backslashes.
size_t start = i, end = start + 1;
- for (; end < arg.size() && arg[end] == '\\'; ++end) {}
+ for (; end < arg.size() && arg[end] == '\\'; ++end) {
+ }
size_t backslash_count = end - start;
// Backslashes are escapes only if the run is followed by a double quote.
@@ -153,26 +155,18 @@
} // namespace
-CommandLine::CommandLine(NoProgram no_program)
- : argv_(1),
- begin_args_(1) {
-}
+CommandLine::CommandLine(NoProgram no_program) : argv_(1), begin_args_(1) {}
-CommandLine::CommandLine(const FilePath& program)
- : argv_(1),
- begin_args_(1) {
+CommandLine::CommandLine(const FilePath& program) : argv_(1), begin_args_(1) {
SetProgram(program);
}
CommandLine::CommandLine(int argc, const CommandLine::CharType* const* argv)
- : argv_(1),
- begin_args_(1) {
+ : argv_(1), begin_args_(1) {
InitFromArgv(argc, argv);
}
-CommandLine::CommandLine(const StringVector& argv)
- : argv_(1),
- begin_args_(1) {
+CommandLine::CommandLine(const StringVector& argv) : argv_(1), begin_args_(1) {
InitFromArgv(argv);
}
diff --git a/base/command_line.h b/base/command_line.h
index c8394ee..7530d66 100644
--- a/base/command_line.h
+++ b/base/command_line.h
@@ -174,8 +174,7 @@
// Append a switch [with optional value] to the command line.
// Note: Switches will precede arguments regardless of appending order.
void AppendSwitch(const std::string& switch_string);
- void AppendSwitchPath(const std::string& switch_string,
- const FilePath& path);
+ void AppendSwitchPath(const std::string& switch_string, const FilePath& path);
void AppendSwitchNative(const std::string& switch_string,
const StringType& value);
void AppendSwitchASCII(const std::string& switch_string,
diff --git a/base/compiler_specific.h b/base/compiler_specific.h
index c27c7bc..b548aa6 100644
--- a/base/compiler_specific.h
+++ b/base/compiler_specific.h
@@ -25,12 +25,12 @@
// MSVC_SUPPRESS_WARNING disables warning |n| for the remainder of the line and
// for the next line of the source file.
-#define MSVC_SUPPRESS_WARNING(n) __pragma(warning(suppress:n))
+#define MSVC_SUPPRESS_WARNING(n) __pragma(warning(suppress : n))
// MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled.
// The warning remains disabled until popped by MSVC_POP_WARNING.
-#define MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \
- __pragma(warning(disable:n))
+#define MSVC_PUSH_DISABLE_WARNING(n) \
+ __pragma(warning(push)) __pragma(warning(disable : n))
// MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level. The level
// remains in effect until popped by MSVC_POP_WARNING(). Use 0 to disable all
@@ -136,7 +136,7 @@
// (This is undocumented but matches what the system C headers do.)
#if defined(COMPILER_GCC) || defined(__clang__)
#define PRINTF_FORMAT(format_param, dots_param) \
- __attribute__((format(printf, format_param, dots_param)))
+ __attribute__((format(printf, format_param, dots_param)))
#else
#define PRINTF_FORMAT(format_param, dots_param)
#endif
@@ -165,14 +165,14 @@
// Mark a memory region fully initialized.
// Use this to annotate code that deliberately reads uninitialized data, for
// example a GC scavenging root set pointers from the stack.
-#define MSAN_UNPOISON(p, size) __msan_unpoison(p, size)
+#define MSAN_UNPOISON(p, size) __msan_unpoison(p, size)
// Check a memory region for initializedness, as if it was being used here.
// If any bits are uninitialized, crash with an MSan report.
// Use this to sanitize data which MSan won't be able to track, e.g. before
// passing data to another process via shared memory.
#define MSAN_CHECK_MEM_IS_INITIALIZED(p, size) \
- __msan_check_mem_is_initialized(p, size)
+ __msan_check_mem_is_initialized(p, size)
#else // MEMORY_SANITIZER
#define MSAN_UNPOISON(p, size)
#define MSAN_CHECK_MEM_IS_INITIALIZED(p, size)
diff --git a/base/containers/span.h b/base/containers/span.h
index f1e0000..c971861 100644
--- a/base/containers/span.h
+++ b/base/containers/span.h
@@ -267,9 +267,9 @@
template <size_t Offset, size_t Count = dynamic_extent>
constexpr span<T,
(Count != dynamic_extent
- ? Count
- : (Extent != dynamic_extent ? Extent - Offset
- : dynamic_extent))>
+ ? Count
+ : (Extent != dynamic_extent ? Extent - Offset
+ : dynamic_extent))>
subspan() const noexcept {
static_assert(Extent == dynamic_extent || Offset <= Extent,
"Offset must not exceed Extent");
diff --git a/base/environment.cc b/base/environment.cc
index fed01d0..19bc20e 100644
--- a/base/environment.cc
+++ b/base/environment.cc
@@ -143,8 +143,7 @@
#if defined(OS_WIN)
-string16 AlterEnvironment(const wchar_t* env,
- const EnvironmentMap& changes) {
+string16 AlterEnvironment(const wchar_t* env, const EnvironmentMap& changes) {
string16 result;
// First copy all unmodified values to the output.
@@ -163,8 +162,8 @@
}
// Now append all modified and new values.
- for (EnvironmentMap::const_iterator i = changes.begin();
- i != changes.end(); ++i) {
+ for (EnvironmentMap::const_iterator i = changes.begin(); i != changes.end();
+ ++i) {
if (!i->second.empty()) {
result.append(i->first);
result.push_back('=');
@@ -203,8 +202,8 @@
}
// Now append all modified and new values.
- for (EnvironmentMap::const_iterator i = changes.begin();
- i != changes.end(); ++i) {
+ for (EnvironmentMap::const_iterator i = changes.begin(); i != changes.end();
+ ++i) {
if (!i->second.empty()) {
result_indices.push_back(value_storage.size());
value_storage.append(i->first);
@@ -220,8 +219,8 @@
std::unique_ptr<char* []> result(new char*[pointer_count_required]);
// The string storage goes after the array of pointers.
- char* storage_data = reinterpret_cast<char*>(
- &result.get()[result_indices.size() + 1]);
+ char* storage_data =
+ reinterpret_cast<char*>(&result.get()[result_indices.size() + 1]);
if (!value_storage.empty())
memcpy(storage_data, value_storage.data(), value_storage.size());
diff --git a/base/environment.h b/base/environment.h
index 2d5976d..135e3c8 100644
--- a/base/environment.h
+++ b/base/environment.h
@@ -45,7 +45,6 @@
virtual bool UnSetVar(StringPiece variable_name) = 0;
};
-
#if defined(OS_WIN)
typedef string16 NativeEnvironmentString;
@@ -62,8 +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 wchar_t* env, const EnvironmentMap& changes);
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
@@ -78,9 +76,8 @@
// returned array will have appended to it the storage for the array itself so
// there is only one pointer to manage, but this means that you can't copy the
// array without keeping the original around.
-std::unique_ptr<char* []> AlterEnvironment(
- const char* const* env,
- const EnvironmentMap& changes);
+std::unique_ptr<char* []> AlterEnvironment(const char* const* env,
+ const EnvironmentMap& changes);
#endif
diff --git a/base/files/file.cc b/base/files/file.cc
index 7485b1a..8f779d5 100644
--- a/base/files/file.cc
+++ b/base/files/file.cc
@@ -13,19 +13,12 @@
namespace base {
-File::Info::Info()
- : size(0),
- is_directory(false),
- is_symbolic_link(false) {
-}
+File::Info::Info() : size(0), is_directory(false), is_symbolic_link(false) {}
File::Info::~Info() = default;
File::File()
- : error_details_(FILE_ERROR_FAILED),
- created_(false),
- async_(false) {
-}
+ : error_details_(FILE_ERROR_FAILED), created_(false), async_(false) {}
#if !defined(OS_NACL)
File::File(const FilePath& path, uint32_t flags)
@@ -45,10 +38,7 @@
}
File::File(Error error_details)
- : error_details_(error_details),
- created_(false),
- async_(false) {
-}
+ : error_details_(error_details), created_(false), async_(false) {}
File::File(File&& other)
: file_(other.TakePlatformFile()),
diff --git a/base/files/file.h b/base/files/file.h
index c554249..49a2cb4 100644
--- a/base/files/file.h
+++ b/base/files/file.h
@@ -106,11 +106,7 @@
};
// This explicit mapping matches both FILE_ on Windows and SEEK_ on Linux.
- enum Whence {
- FROM_BEGIN = 0,
- FROM_CURRENT = 1,
- FROM_END = 2
- };
+ enum Whence { FROM_BEGIN = 0, FROM_CURRENT = 1, FROM_END = 2 };
// Used to hold information about a given file.
// If you add more fields to this structure (platform-specific fields are OK),
@@ -361,4 +357,3 @@
} // namespace base
#endif // BASE_FILES_FILE_H_
-
diff --git a/base/files/file_enumerator.h b/base/files/file_enumerator.h
index 45ce88b..905871d 100644
--- a/base/files/file_enumerator.h
+++ b/base/files/file_enumerator.h
@@ -111,9 +111,7 @@
// since the underlying code uses OS-specific matching routines. In general,
// Windows matching is less featureful than others, so test there first.
// If unspecified, this will match all files.
- FileEnumerator(const FilePath& root_path,
- bool recursive,
- int file_type);
+ FileEnumerator(const FilePath& root_path, bool recursive, int file_type);
FileEnumerator(const FilePath& root_path,
bool recursive,
int file_type,
diff --git a/base/files/file_path.cc b/base/files/file_path.cc
index 969a977..325b9b2 100644
--- a/base/files/file_path.cc
+++ b/base/files/file_path.cc
@@ -33,8 +33,8 @@
namespace {
-const char* const kCommonDoubleExtensionSuffixes[] = { "gz", "z", "bz2", "bz" };
-const char* const kCommonDoubleExtensions[] = { "user.js" };
+const char* const kCommonDoubleExtensionSuffixes[] = {"gz", "z", "bz2", "bz"};
+const char* const kCommonDoubleExtensions[] = {"user.js"};
const FilePath::CharType kStringTerminator = FILE_PATH_LITERAL('\0');
@@ -81,20 +81,19 @@
if (letter != StringType::npos) {
// Look for a separator right after the drive specification.
return path.length() > letter + 1 &&
- FilePath::IsSeparator(path[letter + 1]);
+ FilePath::IsSeparator(path[letter + 1]);
}
// Look for a pair of leading separators.
- return path.length() > 1 &&
- FilePath::IsSeparator(path[0]) && FilePath::IsSeparator(path[1]);
-#else // FILE_PATH_USES_DRIVE_LETTERS
+ return path.length() > 1 && FilePath::IsSeparator(path[0]) &&
+ FilePath::IsSeparator(path[1]);
+#else // FILE_PATH_USES_DRIVE_LETTERS
// Look for a separator in the first position.
return path.length() > 0 && FilePath::IsSeparator(path[0]);
#endif // FILE_PATH_USES_DRIVE_LETTERS
}
bool AreAllSeparators(const StringType& input) {
- for (StringType::const_iterator it = input.begin();
- it != input.end(); ++it) {
+ for (StringType::const_iterator it = input.begin(); it != input.end(); ++it) {
if (!FilePath::IsSeparator(*it))
return false;
}
@@ -126,9 +125,8 @@
const StringType::size_type penultimate_dot =
path.rfind(FilePath::kExtensionSeparator, last_dot - 1);
- const StringType::size_type last_separator =
- path.find_last_of(FilePath::kSeparators, last_dot - 1,
- FilePath::kSeparatorsLength - 1);
+ const StringType::size_type last_separator = path.find_last_of(
+ FilePath::kSeparators, last_dot - 1, FilePath::kSeparatorsLength - 1);
if (penultimate_dot == StringType::npos ||
(last_separator != StringType::npos &&
@@ -189,7 +187,7 @@
bool FilePath::operator==(const FilePath& that) const {
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
return EqualDriveLetterCaseInsensitive(this->path_, that.path_);
-#else // defined(FILE_PATH_USES_DRIVE_LETTERS)
+#else // defined(FILE_PATH_USES_DRIVE_LETTERS)
return path_ == that.path_;
#endif // defined(FILE_PATH_USES_DRIVE_LETTERS)
}
@@ -197,7 +195,7 @@
bool FilePath::operator!=(const FilePath& that) const {
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
return !EqualDriveLetterCaseInsensitive(this->path_, that.path_);
-#else // defined(FILE_PATH_USES_DRIVE_LETTERS)
+#else // defined(FILE_PATH_USES_DRIVE_LETTERS)
return path_ != that.path_;
#endif // defined(FILE_PATH_USES_DRIVE_LETTERS)
}
@@ -256,8 +254,7 @@
return AppendRelativePath(child, nullptr);
}
-bool FilePath::AppendRelativePath(const FilePath& child,
- FilePath* path) const {
+bool FilePath::AppendRelativePath(const FilePath& child, FilePath* path) const {
std::vector<StringType> parent_components;
std::vector<StringType> child_components;
GetComponents(&parent_components);
@@ -269,8 +266,7 @@
std::vector<StringType>::const_iterator parent_comp =
parent_components.begin();
- std::vector<StringType>::const_iterator child_comp =
- child_components.begin();
+ std::vector<StringType>::const_iterator child_comp = child_components.begin();
#if defined(FILE_PATH_USES_DRIVE_LETTERS)
// Windows can access case sensitive filesystems, so component
@@ -314,9 +310,8 @@
// resizes below using letter will still be valid.
StringType::size_type letter = FindDriveLetter(new_path.path_);
- StringType::size_type last_separator =
- new_path.path_.find_last_of(kSeparators, StringType::npos,
- kSeparatorsLength - 1);
+ StringType::size_type last_separator = new_path.path_.find_last_of(
+ kSeparators, StringType::npos, kSeparatorsLength - 1);
if (last_separator == StringType::npos) {
// path_ is in the current directory.
new_path.path_.resize(letter + 1);
@@ -352,9 +347,8 @@
// Keep everything after the final separator, but if the pathname is only
// one character and it's a separator, leave it alone.
- StringType::size_type last_separator =
- new_path.path_.find_last_of(kSeparators, StringType::npos,
- kSeparatorsLength - 1);
+ StringType::size_type last_separator = new_path.path_.find_last_of(
+ kSeparators, StringType::npos, kSeparatorsLength - 1);
if (last_separator != StringType::npos &&
last_separator < new_path.path_.length() - 1) {
new_path.path_.erase(0, last_separator + 1);
@@ -417,8 +411,7 @@
return FilePath(ret);
}
-FilePath FilePath::InsertBeforeExtensionASCII(StringPiece suffix)
- const {
+FilePath FilePath::InsertBeforeExtensionASCII(StringPiece suffix) const {
DCHECK(IsStringASCII(suffix));
#if defined(OS_WIN)
return InsertBeforeExtension(ASCIIToUTF16(suffix));
@@ -682,7 +675,7 @@
StringPieceType::const_iterator i2 = string2.begin();
StringPieceType::const_iterator string1end = string1.end();
StringPieceType::const_iterator string2end = string2.end();
- for ( ; i1 != string1end && i2 != string2end; ++i1, ++i2) {
+ for (; i1 != string1end && i2 != string2end; ++i1, ++i2) {
wchar_t c1 =
(wchar_t)LOWORD(char_upper_api((LPWSTR)(DWORD_PTR)MAKELONG(*i1, 0)));
wchar_t c2 =
@@ -702,7 +695,8 @@
#elif defined(OS_MACOSX)
// Mac OS X specific implementation of file string comparisons.
-// cf. http://developer.apple.com/mac/library/technotes/tn/tn1150.html#UnicodeSubtleties
+// cf.
+// http://developer.apple.com/mac/library/technotes/tn/tn1150.html#UnicodeSubtleties
//
// "When using CreateTextEncoding to create a text encoding, you should set
// the TextEncodingBase to kTextEncodingUnicodeV2_0, set the
@@ -713,7 +707,8 @@
//
// Another technical article for X 10.4 updates this: one should use
// the new (unambiguous) kUnicodeHFSPlusDecompVariant.
-// cf. http://developer.apple.com/mac/library/releasenotes/TextFonts/RN-TEC/index.html
+// cf.
+// http://developer.apple.com/mac/library/releasenotes/TextFonts/RN-TEC/index.html
//
// This implementation uses CFStringGetFileSystemRepresentation() to get the
// decomposed form, and an adapted version of the FastUnicodeCompare as
@@ -733,390 +728,390 @@
namespace {
const UInt16 lower_case_table[] = {
- // High-byte indices ( == 0 iff no case mapping and no ignorables )
+ // High-byte indices ( == 0 iff no case mapping and no ignorables )
- /* 0 */ 0x0100, 0x0200, 0x0000, 0x0300, 0x0400, 0x0500, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 1 */ 0x0600, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 2 */ 0x0700, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 3 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 4 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 5 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 6 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 7 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 9 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* A */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* B */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* C */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* D */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* E */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* F */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0900, 0x0A00,
+ /* 0 */ 0x0100, 0x0200, 0x0000, 0x0300, 0x0400, 0x0500, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 1 */ 0x0600, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 2 */ 0x0700, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 3 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 4 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 5 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 6 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 7 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 9 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* A */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* B */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* C */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* D */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* E */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* F */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0900, 0x0A00,
- // Table 1 (for high byte 0x00)
+ // Table 1 (for high byte 0x00)
- /* 0 */ 0xFFFF, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
- 0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
- /* 1 */ 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
- 0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
- /* 2 */ 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
- 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
- /* 3 */ 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
- 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
- /* 4 */ 0x0040, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
- 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
- /* 5 */ 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
- 0x0078, 0x0079, 0x007A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
- /* 6 */ 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
- 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
- /* 7 */ 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
- 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
- /* 8 */ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
- 0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
- /* 9 */ 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
- 0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
- /* A */ 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
- 0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
- /* B */ 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
- 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
- /* C */ 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00E6, 0x00C7,
- 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
- /* D */ 0x00F0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
- 0x00F8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00FE, 0x00DF,
- /* E */ 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
- 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
- /* F */ 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
- 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF,
+ /* 0 */ 0xFFFF, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+ 0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+ /* 1 */ 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+ 0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+ /* 2 */ 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+ 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+ /* 3 */ 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+ 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+ /* 4 */ 0x0040, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+ 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+ /* 5 */ 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+ 0x0078, 0x0079, 0x007A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+ /* 6 */ 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+ 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+ /* 7 */ 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+ 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+ /* 8 */ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+ 0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+ /* 9 */ 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+ 0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+ /* A */ 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+ 0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+ /* B */ 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+ 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
+ /* C */ 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00E6, 0x00C7,
+ 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
+ /* D */ 0x00F0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+ 0x00F8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00FE, 0x00DF,
+ /* E */ 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+ 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+ /* F */ 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+ 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF,
- // Table 2 (for high byte 0x01)
+ // Table 2 (for high byte 0x01)
- /* 0 */ 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 0x0105, 0x0106, 0x0107,
- 0x0108, 0x0109, 0x010A, 0x010B, 0x010C, 0x010D, 0x010E, 0x010F,
- /* 1 */ 0x0111, 0x0111, 0x0112, 0x0113, 0x0114, 0x0115, 0x0116, 0x0117,
- 0x0118, 0x0119, 0x011A, 0x011B, 0x011C, 0x011D, 0x011E, 0x011F,
- /* 2 */ 0x0120, 0x0121, 0x0122, 0x0123, 0x0124, 0x0125, 0x0127, 0x0127,
- 0x0128, 0x0129, 0x012A, 0x012B, 0x012C, 0x012D, 0x012E, 0x012F,
- /* 3 */ 0x0130, 0x0131, 0x0133, 0x0133, 0x0134, 0x0135, 0x0136, 0x0137,
- 0x0138, 0x0139, 0x013A, 0x013B, 0x013C, 0x013D, 0x013E, 0x0140,
- /* 4 */ 0x0140, 0x0142, 0x0142, 0x0143, 0x0144, 0x0145, 0x0146, 0x0147,
- 0x0148, 0x0149, 0x014B, 0x014B, 0x014C, 0x014D, 0x014E, 0x014F,
- /* 5 */ 0x0150, 0x0151, 0x0153, 0x0153, 0x0154, 0x0155, 0x0156, 0x0157,
- 0x0158, 0x0159, 0x015A, 0x015B, 0x015C, 0x015D, 0x015E, 0x015F,
- /* 6 */ 0x0160, 0x0161, 0x0162, 0x0163, 0x0164, 0x0165, 0x0167, 0x0167,
- 0x0168, 0x0169, 0x016A, 0x016B, 0x016C, 0x016D, 0x016E, 0x016F,
- /* 7 */ 0x0170, 0x0171, 0x0172, 0x0173, 0x0174, 0x0175, 0x0176, 0x0177,
- 0x0178, 0x0179, 0x017A, 0x017B, 0x017C, 0x017D, 0x017E, 0x017F,
- /* 8 */ 0x0180, 0x0253, 0x0183, 0x0183, 0x0185, 0x0185, 0x0254, 0x0188,
- 0x0188, 0x0256, 0x0257, 0x018C, 0x018C, 0x018D, 0x01DD, 0x0259,
- /* 9 */ 0x025B, 0x0192, 0x0192, 0x0260, 0x0263, 0x0195, 0x0269, 0x0268,
- 0x0199, 0x0199, 0x019A, 0x019B, 0x026F, 0x0272, 0x019E, 0x0275,
- /* A */ 0x01A0, 0x01A1, 0x01A3, 0x01A3, 0x01A5, 0x01A5, 0x01A6, 0x01A8,
- 0x01A8, 0x0283, 0x01AA, 0x01AB, 0x01AD, 0x01AD, 0x0288, 0x01AF,
- /* B */ 0x01B0, 0x028A, 0x028B, 0x01B4, 0x01B4, 0x01B6, 0x01B6, 0x0292,
- 0x01B9, 0x01B9, 0x01BA, 0x01BB, 0x01BD, 0x01BD, 0x01BE, 0x01BF,
- /* C */ 0x01C0, 0x01C1, 0x01C2, 0x01C3, 0x01C6, 0x01C6, 0x01C6, 0x01C9,
- 0x01C9, 0x01C9, 0x01CC, 0x01CC, 0x01CC, 0x01CD, 0x01CE, 0x01CF,
- /* D */ 0x01D0, 0x01D1, 0x01D2, 0x01D3, 0x01D4, 0x01D5, 0x01D6, 0x01D7,
- 0x01D8, 0x01D9, 0x01DA, 0x01DB, 0x01DC, 0x01DD, 0x01DE, 0x01DF,
- /* E */ 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E5, 0x01E5, 0x01E6, 0x01E7,
- 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF,
- /* F */ 0x01F0, 0x01F3, 0x01F3, 0x01F3, 0x01F4, 0x01F5, 0x01F6, 0x01F7,
- 0x01F8, 0x01F9, 0x01FA, 0x01FB, 0x01FC, 0x01FD, 0x01FE, 0x01FF,
+ /* 0 */ 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 0x0105, 0x0106, 0x0107,
+ 0x0108, 0x0109, 0x010A, 0x010B, 0x010C, 0x010D, 0x010E, 0x010F,
+ /* 1 */ 0x0111, 0x0111, 0x0112, 0x0113, 0x0114, 0x0115, 0x0116, 0x0117,
+ 0x0118, 0x0119, 0x011A, 0x011B, 0x011C, 0x011D, 0x011E, 0x011F,
+ /* 2 */ 0x0120, 0x0121, 0x0122, 0x0123, 0x0124, 0x0125, 0x0127, 0x0127,
+ 0x0128, 0x0129, 0x012A, 0x012B, 0x012C, 0x012D, 0x012E, 0x012F,
+ /* 3 */ 0x0130, 0x0131, 0x0133, 0x0133, 0x0134, 0x0135, 0x0136, 0x0137,
+ 0x0138, 0x0139, 0x013A, 0x013B, 0x013C, 0x013D, 0x013E, 0x0140,
+ /* 4 */ 0x0140, 0x0142, 0x0142, 0x0143, 0x0144, 0x0145, 0x0146, 0x0147,
+ 0x0148, 0x0149, 0x014B, 0x014B, 0x014C, 0x014D, 0x014E, 0x014F,
+ /* 5 */ 0x0150, 0x0151, 0x0153, 0x0153, 0x0154, 0x0155, 0x0156, 0x0157,
+ 0x0158, 0x0159, 0x015A, 0x015B, 0x015C, 0x015D, 0x015E, 0x015F,
+ /* 6 */ 0x0160, 0x0161, 0x0162, 0x0163, 0x0164, 0x0165, 0x0167, 0x0167,
+ 0x0168, 0x0169, 0x016A, 0x016B, 0x016C, 0x016D, 0x016E, 0x016F,
+ /* 7 */ 0x0170, 0x0171, 0x0172, 0x0173, 0x0174, 0x0175, 0x0176, 0x0177,
+ 0x0178, 0x0179, 0x017A, 0x017B, 0x017C, 0x017D, 0x017E, 0x017F,
+ /* 8 */ 0x0180, 0x0253, 0x0183, 0x0183, 0x0185, 0x0185, 0x0254, 0x0188,
+ 0x0188, 0x0256, 0x0257, 0x018C, 0x018C, 0x018D, 0x01DD, 0x0259,
+ /* 9 */ 0x025B, 0x0192, 0x0192, 0x0260, 0x0263, 0x0195, 0x0269, 0x0268,
+ 0x0199, 0x0199, 0x019A, 0x019B, 0x026F, 0x0272, 0x019E, 0x0275,
+ /* A */ 0x01A0, 0x01A1, 0x01A3, 0x01A3, 0x01A5, 0x01A5, 0x01A6, 0x01A8,
+ 0x01A8, 0x0283, 0x01AA, 0x01AB, 0x01AD, 0x01AD, 0x0288, 0x01AF,
+ /* B */ 0x01B0, 0x028A, 0x028B, 0x01B4, 0x01B4, 0x01B6, 0x01B6, 0x0292,
+ 0x01B9, 0x01B9, 0x01BA, 0x01BB, 0x01BD, 0x01BD, 0x01BE, 0x01BF,
+ /* C */ 0x01C0, 0x01C1, 0x01C2, 0x01C3, 0x01C6, 0x01C6, 0x01C6, 0x01C9,
+ 0x01C9, 0x01C9, 0x01CC, 0x01CC, 0x01CC, 0x01CD, 0x01CE, 0x01CF,
+ /* D */ 0x01D0, 0x01D1, 0x01D2, 0x01D3, 0x01D4, 0x01D5, 0x01D6, 0x01D7,
+ 0x01D8, 0x01D9, 0x01DA, 0x01DB, 0x01DC, 0x01DD, 0x01DE, 0x01DF,
+ /* E */ 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E5, 0x01E5, 0x01E6, 0x01E7,
+ 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF,
+ /* F */ 0x01F0, 0x01F3, 0x01F3, 0x01F3, 0x01F4, 0x01F5, 0x01F6, 0x01F7,
+ 0x01F8, 0x01F9, 0x01FA, 0x01FB, 0x01FC, 0x01FD, 0x01FE, 0x01FF,
- // Table 3 (for high byte 0x03)
+ // Table 3 (for high byte 0x03)
- /* 0 */ 0x0300, 0x0301, 0x0302, 0x0303, 0x0304, 0x0305, 0x0306, 0x0307,
- 0x0308, 0x0309, 0x030A, 0x030B, 0x030C, 0x030D, 0x030E, 0x030F,
- /* 1 */ 0x0310, 0x0311, 0x0312, 0x0313, 0x0314, 0x0315, 0x0316, 0x0317,
- 0x0318, 0x0319, 0x031A, 0x031B, 0x031C, 0x031D, 0x031E, 0x031F,
- /* 2 */ 0x0320, 0x0321, 0x0322, 0x0323, 0x0324, 0x0325, 0x0326, 0x0327,
- 0x0328, 0x0329, 0x032A, 0x032B, 0x032C, 0x032D, 0x032E, 0x032F,
- /* 3 */ 0x0330, 0x0331, 0x0332, 0x0333, 0x0334, 0x0335, 0x0336, 0x0337,
- 0x0338, 0x0339, 0x033A, 0x033B, 0x033C, 0x033D, 0x033E, 0x033F,
- /* 4 */ 0x0340, 0x0341, 0x0342, 0x0343, 0x0344, 0x0345, 0x0346, 0x0347,
- 0x0348, 0x0349, 0x034A, 0x034B, 0x034C, 0x034D, 0x034E, 0x034F,
- /* 5 */ 0x0350, 0x0351, 0x0352, 0x0353, 0x0354, 0x0355, 0x0356, 0x0357,
- 0x0358, 0x0359, 0x035A, 0x035B, 0x035C, 0x035D, 0x035E, 0x035F,
- /* 6 */ 0x0360, 0x0361, 0x0362, 0x0363, 0x0364, 0x0365, 0x0366, 0x0367,
- 0x0368, 0x0369, 0x036A, 0x036B, 0x036C, 0x036D, 0x036E, 0x036F,
- /* 7 */ 0x0370, 0x0371, 0x0372, 0x0373, 0x0374, 0x0375, 0x0376, 0x0377,
- 0x0378, 0x0379, 0x037A, 0x037B, 0x037C, 0x037D, 0x037E, 0x037F,
- /* 8 */ 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386, 0x0387,
- 0x0388, 0x0389, 0x038A, 0x038B, 0x038C, 0x038D, 0x038E, 0x038F,
- /* 9 */ 0x0390, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
- 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
- /* A */ 0x03C0, 0x03C1, 0x03A2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
- 0x03C8, 0x03C9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
- /* B */ 0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
- 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
- /* C */ 0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
- 0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0x03CF,
- /* D */ 0x03D0, 0x03D1, 0x03D2, 0x03D3, 0x03D4, 0x03D5, 0x03D6, 0x03D7,
- 0x03D8, 0x03D9, 0x03DA, 0x03DB, 0x03DC, 0x03DD, 0x03DE, 0x03DF,
- /* E */ 0x03E0, 0x03E1, 0x03E3, 0x03E3, 0x03E5, 0x03E5, 0x03E7, 0x03E7,
- 0x03E9, 0x03E9, 0x03EB, 0x03EB, 0x03ED, 0x03ED, 0x03EF, 0x03EF,
- /* F */ 0x03F0, 0x03F1, 0x03F2, 0x03F3, 0x03F4, 0x03F5, 0x03F6, 0x03F7,
- 0x03F8, 0x03F9, 0x03FA, 0x03FB, 0x03FC, 0x03FD, 0x03FE, 0x03FF,
+ /* 0 */ 0x0300, 0x0301, 0x0302, 0x0303, 0x0304, 0x0305, 0x0306, 0x0307,
+ 0x0308, 0x0309, 0x030A, 0x030B, 0x030C, 0x030D, 0x030E, 0x030F,
+ /* 1 */ 0x0310, 0x0311, 0x0312, 0x0313, 0x0314, 0x0315, 0x0316, 0x0317,
+ 0x0318, 0x0319, 0x031A, 0x031B, 0x031C, 0x031D, 0x031E, 0x031F,
+ /* 2 */ 0x0320, 0x0321, 0x0322, 0x0323, 0x0324, 0x0325, 0x0326, 0x0327,
+ 0x0328, 0x0329, 0x032A, 0x032B, 0x032C, 0x032D, 0x032E, 0x032F,
+ /* 3 */ 0x0330, 0x0331, 0x0332, 0x0333, 0x0334, 0x0335, 0x0336, 0x0337,
+ 0x0338, 0x0339, 0x033A, 0x033B, 0x033C, 0x033D, 0x033E, 0x033F,
+ /* 4 */ 0x0340, 0x0341, 0x0342, 0x0343, 0x0344, 0x0345, 0x0346, 0x0347,
+ 0x0348, 0x0349, 0x034A, 0x034B, 0x034C, 0x034D, 0x034E, 0x034F,
+ /* 5 */ 0x0350, 0x0351, 0x0352, 0x0353, 0x0354, 0x0355, 0x0356, 0x0357,
+ 0x0358, 0x0359, 0x035A, 0x035B, 0x035C, 0x035D, 0x035E, 0x035F,
+ /* 6 */ 0x0360, 0x0361, 0x0362, 0x0363, 0x0364, 0x0365, 0x0366, 0x0367,
+ 0x0368, 0x0369, 0x036A, 0x036B, 0x036C, 0x036D, 0x036E, 0x036F,
+ /* 7 */ 0x0370, 0x0371, 0x0372, 0x0373, 0x0374, 0x0375, 0x0376, 0x0377,
+ 0x0378, 0x0379, 0x037A, 0x037B, 0x037C, 0x037D, 0x037E, 0x037F,
+ /* 8 */ 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386, 0x0387,
+ 0x0388, 0x0389, 0x038A, 0x038B, 0x038C, 0x038D, 0x038E, 0x038F,
+ /* 9 */ 0x0390, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
+ 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
+ /* A */ 0x03C0, 0x03C1, 0x03A2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
+ 0x03C8, 0x03C9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
+ /* B */ 0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
+ 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
+ /* C */ 0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
+ 0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0x03CF,
+ /* D */ 0x03D0, 0x03D1, 0x03D2, 0x03D3, 0x03D4, 0x03D5, 0x03D6, 0x03D7,
+ 0x03D8, 0x03D9, 0x03DA, 0x03DB, 0x03DC, 0x03DD, 0x03DE, 0x03DF,
+ /* E */ 0x03E0, 0x03E1, 0x03E3, 0x03E3, 0x03E5, 0x03E5, 0x03E7, 0x03E7,
+ 0x03E9, 0x03E9, 0x03EB, 0x03EB, 0x03ED, 0x03ED, 0x03EF, 0x03EF,
+ /* F */ 0x03F0, 0x03F1, 0x03F2, 0x03F3, 0x03F4, 0x03F5, 0x03F6, 0x03F7,
+ 0x03F8, 0x03F9, 0x03FA, 0x03FB, 0x03FC, 0x03FD, 0x03FE, 0x03FF,
- // Table 4 (for high byte 0x04)
+ // Table 4 (for high byte 0x04)
- /* 0 */ 0x0400, 0x0401, 0x0452, 0x0403, 0x0454, 0x0455, 0x0456, 0x0407,
- 0x0458, 0x0459, 0x045A, 0x045B, 0x040C, 0x040D, 0x040E, 0x045F,
- /* 1 */ 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
- 0x0438, 0x0419, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
- /* 2 */ 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
- 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
- /* 3 */ 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
- 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
- /* 4 */ 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
- 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
- /* 5 */ 0x0450, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
- 0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x045D, 0x045E, 0x045F,
- /* 6 */ 0x0461, 0x0461, 0x0463, 0x0463, 0x0465, 0x0465, 0x0467, 0x0467,
- 0x0469, 0x0469, 0x046B, 0x046B, 0x046D, 0x046D, 0x046F, 0x046F,
- /* 7 */ 0x0471, 0x0471, 0x0473, 0x0473, 0x0475, 0x0475, 0x0476, 0x0477,
- 0x0479, 0x0479, 0x047B, 0x047B, 0x047D, 0x047D, 0x047F, 0x047F,
- /* 8 */ 0x0481, 0x0481, 0x0482, 0x0483, 0x0484, 0x0485, 0x0486, 0x0487,
- 0x0488, 0x0489, 0x048A, 0x048B, 0x048C, 0x048D, 0x048E, 0x048F,
- /* 9 */ 0x0491, 0x0491, 0x0493, 0x0493, 0x0495, 0x0495, 0x0497, 0x0497,
- 0x0499, 0x0499, 0x049B, 0x049B, 0x049D, 0x049D, 0x049F, 0x049F,
- /* A */ 0x04A1, 0x04A1, 0x04A3, 0x04A3, 0x04A5, 0x04A5, 0x04A7, 0x04A7,
- 0x04A9, 0x04A9, 0x04AB, 0x04AB, 0x04AD, 0x04AD, 0x04AF, 0x04AF,
- /* B */ 0x04B1, 0x04B1, 0x04B3, 0x04B3, 0x04B5, 0x04B5, 0x04B7, 0x04B7,
- 0x04B9, 0x04B9, 0x04BB, 0x04BB, 0x04BD, 0x04BD, 0x04BF, 0x04BF,
- /* C */ 0x04C0, 0x04C1, 0x04C2, 0x04C4, 0x04C4, 0x04C5, 0x04C6, 0x04C8,
- 0x04C8, 0x04C9, 0x04CA, 0x04CC, 0x04CC, 0x04CD, 0x04CE, 0x04CF,
- /* D */ 0x04D0, 0x04D1, 0x04D2, 0x04D3, 0x04D4, 0x04D5, 0x04D6, 0x04D7,
- 0x04D8, 0x04D9, 0x04DA, 0x04DB, 0x04DC, 0x04DD, 0x04DE, 0x04DF,
- /* E */ 0x04E0, 0x04E1, 0x04E2, 0x04E3, 0x04E4, 0x04E5, 0x04E6, 0x04E7,
- 0x04E8, 0x04E9, 0x04EA, 0x04EB, 0x04EC, 0x04ED, 0x04EE, 0x04EF,
- /* F */ 0x04F0, 0x04F1, 0x04F2, 0x04F3, 0x04F4, 0x04F5, 0x04F6, 0x04F7,
- 0x04F8, 0x04F9, 0x04FA, 0x04FB, 0x04FC, 0x04FD, 0x04FE, 0x04FF,
+ /* 0 */ 0x0400, 0x0401, 0x0452, 0x0403, 0x0454, 0x0455, 0x0456, 0x0407,
+ 0x0458, 0x0459, 0x045A, 0x045B, 0x040C, 0x040D, 0x040E, 0x045F,
+ /* 1 */ 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
+ 0x0438, 0x0419, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+ /* 2 */ 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+ 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+ /* 3 */ 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
+ 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+ /* 4 */ 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+ 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+ /* 5 */ 0x0450, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
+ 0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x045D, 0x045E, 0x045F,
+ /* 6 */ 0x0461, 0x0461, 0x0463, 0x0463, 0x0465, 0x0465, 0x0467, 0x0467,
+ 0x0469, 0x0469, 0x046B, 0x046B, 0x046D, 0x046D, 0x046F, 0x046F,
+ /* 7 */ 0x0471, 0x0471, 0x0473, 0x0473, 0x0475, 0x0475, 0x0476, 0x0477,
+ 0x0479, 0x0479, 0x047B, 0x047B, 0x047D, 0x047D, 0x047F, 0x047F,
+ /* 8 */ 0x0481, 0x0481, 0x0482, 0x0483, 0x0484, 0x0485, 0x0486, 0x0487,
+ 0x0488, 0x0489, 0x048A, 0x048B, 0x048C, 0x048D, 0x048E, 0x048F,
+ /* 9 */ 0x0491, 0x0491, 0x0493, 0x0493, 0x0495, 0x0495, 0x0497, 0x0497,
+ 0x0499, 0x0499, 0x049B, 0x049B, 0x049D, 0x049D, 0x049F, 0x049F,
+ /* A */ 0x04A1, 0x04A1, 0x04A3, 0x04A3, 0x04A5, 0x04A5, 0x04A7, 0x04A7,
+ 0x04A9, 0x04A9, 0x04AB, 0x04AB, 0x04AD, 0x04AD, 0x04AF, 0x04AF,
+ /* B */ 0x04B1, 0x04B1, 0x04B3, 0x04B3, 0x04B5, 0x04B5, 0x04B7, 0x04B7,
+ 0x04B9, 0x04B9, 0x04BB, 0x04BB, 0x04BD, 0x04BD, 0x04BF, 0x04BF,
+ /* C */ 0x04C0, 0x04C1, 0x04C2, 0x04C4, 0x04C4, 0x04C5, 0x04C6, 0x04C8,
+ 0x04C8, 0x04C9, 0x04CA, 0x04CC, 0x04CC, 0x04CD, 0x04CE, 0x04CF,
+ /* D */ 0x04D0, 0x04D1, 0x04D2, 0x04D3, 0x04D4, 0x04D5, 0x04D6, 0x04D7,
+ 0x04D8, 0x04D9, 0x04DA, 0x04DB, 0x04DC, 0x04DD, 0x04DE, 0x04DF,
+ /* E */ 0x04E0, 0x04E1, 0x04E2, 0x04E3, 0x04E4, 0x04E5, 0x04E6, 0x04E7,
+ 0x04E8, 0x04E9, 0x04EA, 0x04EB, 0x04EC, 0x04ED, 0x04EE, 0x04EF,
+ /* F */ 0x04F0, 0x04F1, 0x04F2, 0x04F3, 0x04F4, 0x04F5, 0x04F6, 0x04F7,
+ 0x04F8, 0x04F9, 0x04FA, 0x04FB, 0x04FC, 0x04FD, 0x04FE, 0x04FF,
- // Table 5 (for high byte 0x05)
+ // Table 5 (for high byte 0x05)
- /* 0 */ 0x0500, 0x0501, 0x0502, 0x0503, 0x0504, 0x0505, 0x0506, 0x0507,
- 0x0508, 0x0509, 0x050A, 0x050B, 0x050C, 0x050D, 0x050E, 0x050F,
- /* 1 */ 0x0510, 0x0511, 0x0512, 0x0513, 0x0514, 0x0515, 0x0516, 0x0517,
- 0x0518, 0x0519, 0x051A, 0x051B, 0x051C, 0x051D, 0x051E, 0x051F,
- /* 2 */ 0x0520, 0x0521, 0x0522, 0x0523, 0x0524, 0x0525, 0x0526, 0x0527,
- 0x0528, 0x0529, 0x052A, 0x052B, 0x052C, 0x052D, 0x052E, 0x052F,
- /* 3 */ 0x0530, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567,
- 0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F,
- /* 4 */ 0x0570, 0x0571, 0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577,
- 0x0578, 0x0579, 0x057A, 0x057B, 0x057C, 0x057D, 0x057E, 0x057F,
- /* 5 */ 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585, 0x0586, 0x0557,
- 0x0558, 0x0559, 0x055A, 0x055B, 0x055C, 0x055D, 0x055E, 0x055F,
- /* 6 */ 0x0560, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567,
- 0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F,
- /* 7 */ 0x0570, 0x0571, 0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577,
- 0x0578, 0x0579, 0x057A, 0x057B, 0x057C, 0x057D, 0x057E, 0x057F,
- /* 8 */ 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585, 0x0586, 0x0587,
- 0x0588, 0x0589, 0x058A, 0x058B, 0x058C, 0x058D, 0x058E, 0x058F,
- /* 9 */ 0x0590, 0x0591, 0x0592, 0x0593, 0x0594, 0x0595, 0x0596, 0x0597,
- 0x0598, 0x0599, 0x059A, 0x059B, 0x059C, 0x059D, 0x059E, 0x059F,
- /* A */ 0x05A0, 0x05A1, 0x05A2, 0x05A3, 0x05A4, 0x05A5, 0x05A6, 0x05A7,
- 0x05A8, 0x05A9, 0x05AA, 0x05AB, 0x05AC, 0x05AD, 0x05AE, 0x05AF,
- /* B */ 0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7,
- 0x05B8, 0x05B9, 0x05BA, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
- /* C */ 0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05C4, 0x05C5, 0x05C6, 0x05C7,
- 0x05C8, 0x05C9, 0x05CA, 0x05CB, 0x05CC, 0x05CD, 0x05CE, 0x05CF,
- /* D */ 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
- 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
- /* E */ 0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
- 0x05E8, 0x05E9, 0x05EA, 0x05EB, 0x05EC, 0x05ED, 0x05EE, 0x05EF,
- /* F */ 0x05F0, 0x05F1, 0x05F2, 0x05F3, 0x05F4, 0x05F5, 0x05F6, 0x05F7,
- 0x05F8, 0x05F9, 0x05FA, 0x05FB, 0x05FC, 0x05FD, 0x05FE, 0x05FF,
+ /* 0 */ 0x0500, 0x0501, 0x0502, 0x0503, 0x0504, 0x0505, 0x0506, 0x0507,
+ 0x0508, 0x0509, 0x050A, 0x050B, 0x050C, 0x050D, 0x050E, 0x050F,
+ /* 1 */ 0x0510, 0x0511, 0x0512, 0x0513, 0x0514, 0x0515, 0x0516, 0x0517,
+ 0x0518, 0x0519, 0x051A, 0x051B, 0x051C, 0x051D, 0x051E, 0x051F,
+ /* 2 */ 0x0520, 0x0521, 0x0522, 0x0523, 0x0524, 0x0525, 0x0526, 0x0527,
+ 0x0528, 0x0529, 0x052A, 0x052B, 0x052C, 0x052D, 0x052E, 0x052F,
+ /* 3 */ 0x0530, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567,
+ 0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F,
+ /* 4 */ 0x0570, 0x0571, 0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577,
+ 0x0578, 0x0579, 0x057A, 0x057B, 0x057C, 0x057D, 0x057E, 0x057F,
+ /* 5 */ 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585, 0x0586, 0x0557,
+ 0x0558, 0x0559, 0x055A, 0x055B, 0x055C, 0x055D, 0x055E, 0x055F,
+ /* 6 */ 0x0560, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567,
+ 0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F,
+ /* 7 */ 0x0570, 0x0571, 0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577,
+ 0x0578, 0x0579, 0x057A, 0x057B, 0x057C, 0x057D, 0x057E, 0x057F,
+ /* 8 */ 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585, 0x0586, 0x0587,
+ 0x0588, 0x0589, 0x058A, 0x058B, 0x058C, 0x058D, 0x058E, 0x058F,
+ /* 9 */ 0x0590, 0x0591, 0x0592, 0x0593, 0x0594, 0x0595, 0x0596, 0x0597,
+ 0x0598, 0x0599, 0x059A, 0x059B, 0x059C, 0x059D, 0x059E, 0x059F,
+ /* A */ 0x05A0, 0x05A1, 0x05A2, 0x05A3, 0x05A4, 0x05A5, 0x05A6, 0x05A7,
+ 0x05A8, 0x05A9, 0x05AA, 0x05AB, 0x05AC, 0x05AD, 0x05AE, 0x05AF,
+ /* B */ 0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7,
+ 0x05B8, 0x05B9, 0x05BA, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
+ /* C */ 0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05C4, 0x05C5, 0x05C6, 0x05C7,
+ 0x05C8, 0x05C9, 0x05CA, 0x05CB, 0x05CC, 0x05CD, 0x05CE, 0x05CF,
+ /* D */ 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
+ 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
+ /* E */ 0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
+ 0x05E8, 0x05E9, 0x05EA, 0x05EB, 0x05EC, 0x05ED, 0x05EE, 0x05EF,
+ /* F */ 0x05F0, 0x05F1, 0x05F2, 0x05F3, 0x05F4, 0x05F5, 0x05F6, 0x05F7,
+ 0x05F8, 0x05F9, 0x05FA, 0x05FB, 0x05FC, 0x05FD, 0x05FE, 0x05FF,
- // Table 6 (for high byte 0x10)
+ // Table 6 (for high byte 0x10)
- /* 0 */ 0x1000, 0x1001, 0x1002, 0x1003, 0x1004, 0x1005, 0x1006, 0x1007,
- 0x1008, 0x1009, 0x100A, 0x100B, 0x100C, 0x100D, 0x100E, 0x100F,
- /* 1 */ 0x1010, 0x1011, 0x1012, 0x1013, 0x1014, 0x1015, 0x1016, 0x1017,
- 0x1018, 0x1019, 0x101A, 0x101B, 0x101C, 0x101D, 0x101E, 0x101F,
- /* 2 */ 0x1020, 0x1021, 0x1022, 0x1023, 0x1024, 0x1025, 0x1026, 0x1027,
- 0x1028, 0x1029, 0x102A, 0x102B, 0x102C, 0x102D, 0x102E, 0x102F,
- /* 3 */ 0x1030, 0x1031, 0x1032, 0x1033, 0x1034, 0x1035, 0x1036, 0x1037,
- 0x1038, 0x1039, 0x103A, 0x103B, 0x103C, 0x103D, 0x103E, 0x103F,
- /* 4 */ 0x1040, 0x1041, 0x1042, 0x1043, 0x1044, 0x1045, 0x1046, 0x1047,
- 0x1048, 0x1049, 0x104A, 0x104B, 0x104C, 0x104D, 0x104E, 0x104F,
- /* 5 */ 0x1050, 0x1051, 0x1052, 0x1053, 0x1054, 0x1055, 0x1056, 0x1057,
- 0x1058, 0x1059, 0x105A, 0x105B, 0x105C, 0x105D, 0x105E, 0x105F,
- /* 6 */ 0x1060, 0x1061, 0x1062, 0x1063, 0x1064, 0x1065, 0x1066, 0x1067,
- 0x1068, 0x1069, 0x106A, 0x106B, 0x106C, 0x106D, 0x106E, 0x106F,
- /* 7 */ 0x1070, 0x1071, 0x1072, 0x1073, 0x1074, 0x1075, 0x1076, 0x1077,
- 0x1078, 0x1079, 0x107A, 0x107B, 0x107C, 0x107D, 0x107E, 0x107F,
- /* 8 */ 0x1080, 0x1081, 0x1082, 0x1083, 0x1084, 0x1085, 0x1086, 0x1087,
- 0x1088, 0x1089, 0x108A, 0x108B, 0x108C, 0x108D, 0x108E, 0x108F,
- /* 9 */ 0x1090, 0x1091, 0x1092, 0x1093, 0x1094, 0x1095, 0x1096, 0x1097,
- 0x1098, 0x1099, 0x109A, 0x109B, 0x109C, 0x109D, 0x109E, 0x109F,
- /* A */ 0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7,
- 0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF,
- /* B */ 0x10E0, 0x10E1, 0x10E2, 0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7,
- 0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10EF,
- /* C */ 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10C6, 0x10C7,
- 0x10C8, 0x10C9, 0x10CA, 0x10CB, 0x10CC, 0x10CD, 0x10CE, 0x10CF,
- /* D */ 0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7,
- 0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF,
- /* E */ 0x10E0, 0x10E1, 0x10E2, 0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7,
- 0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10EF,
- /* F */ 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10F6, 0x10F7,
- 0x10F8, 0x10F9, 0x10FA, 0x10FB, 0x10FC, 0x10FD, 0x10FE, 0x10FF,
+ /* 0 */ 0x1000, 0x1001, 0x1002, 0x1003, 0x1004, 0x1005, 0x1006, 0x1007,
+ 0x1008, 0x1009, 0x100A, 0x100B, 0x100C, 0x100D, 0x100E, 0x100F,
+ /* 1 */ 0x1010, 0x1011, 0x1012, 0x1013, 0x1014, 0x1015, 0x1016, 0x1017,
+ 0x1018, 0x1019, 0x101A, 0x101B, 0x101C, 0x101D, 0x101E, 0x101F,
+ /* 2 */ 0x1020, 0x1021, 0x1022, 0x1023, 0x1024, 0x1025, 0x1026, 0x1027,
+ 0x1028, 0x1029, 0x102A, 0x102B, 0x102C, 0x102D, 0x102E, 0x102F,
+ /* 3 */ 0x1030, 0x1031, 0x1032, 0x1033, 0x1034, 0x1035, 0x1036, 0x1037,
+ 0x1038, 0x1039, 0x103A, 0x103B, 0x103C, 0x103D, 0x103E, 0x103F,
+ /* 4 */ 0x1040, 0x1041, 0x1042, 0x1043, 0x1044, 0x1045, 0x1046, 0x1047,
+ 0x1048, 0x1049, 0x104A, 0x104B, 0x104C, 0x104D, 0x104E, 0x104F,
+ /* 5 */ 0x1050, 0x1051, 0x1052, 0x1053, 0x1054, 0x1055, 0x1056, 0x1057,
+ 0x1058, 0x1059, 0x105A, 0x105B, 0x105C, 0x105D, 0x105E, 0x105F,
+ /* 6 */ 0x1060, 0x1061, 0x1062, 0x1063, 0x1064, 0x1065, 0x1066, 0x1067,
+ 0x1068, 0x1069, 0x106A, 0x106B, 0x106C, 0x106D, 0x106E, 0x106F,
+ /* 7 */ 0x1070, 0x1071, 0x1072, 0x1073, 0x1074, 0x1075, 0x1076, 0x1077,
+ 0x1078, 0x1079, 0x107A, 0x107B, 0x107C, 0x107D, 0x107E, 0x107F,
+ /* 8 */ 0x1080, 0x1081, 0x1082, 0x1083, 0x1084, 0x1085, 0x1086, 0x1087,
+ 0x1088, 0x1089, 0x108A, 0x108B, 0x108C, 0x108D, 0x108E, 0x108F,
+ /* 9 */ 0x1090, 0x1091, 0x1092, 0x1093, 0x1094, 0x1095, 0x1096, 0x1097,
+ 0x1098, 0x1099, 0x109A, 0x109B, 0x109C, 0x109D, 0x109E, 0x109F,
+ /* A */ 0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7,
+ 0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF,
+ /* B */ 0x10E0, 0x10E1, 0x10E2, 0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7,
+ 0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10EF,
+ /* C */ 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10C6, 0x10C7,
+ 0x10C8, 0x10C9, 0x10CA, 0x10CB, 0x10CC, 0x10CD, 0x10CE, 0x10CF,
+ /* D */ 0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7,
+ 0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF,
+ /* E */ 0x10E0, 0x10E1, 0x10E2, 0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7,
+ 0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10EF,
+ /* F */ 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10F6, 0x10F7,
+ 0x10F8, 0x10F9, 0x10FA, 0x10FB, 0x10FC, 0x10FD, 0x10FE, 0x10FF,
- // Table 7 (for high byte 0x20)
+ // Table 7 (for high byte 0x20)
- /* 0 */ 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007,
- 0x2008, 0x2009, 0x200A, 0x200B, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 1 */ 0x2010, 0x2011, 0x2012, 0x2013, 0x2014, 0x2015, 0x2016, 0x2017,
- 0x2018, 0x2019, 0x201A, 0x201B, 0x201C, 0x201D, 0x201E, 0x201F,
- /* 2 */ 0x2020, 0x2021, 0x2022, 0x2023, 0x2024, 0x2025, 0x2026, 0x2027,
- 0x2028, 0x2029, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x202F,
- /* 3 */ 0x2030, 0x2031, 0x2032, 0x2033, 0x2034, 0x2035, 0x2036, 0x2037,
- 0x2038, 0x2039, 0x203A, 0x203B, 0x203C, 0x203D, 0x203E, 0x203F,
- /* 4 */ 0x2040, 0x2041, 0x2042, 0x2043, 0x2044, 0x2045, 0x2046, 0x2047,
- 0x2048, 0x2049, 0x204A, 0x204B, 0x204C, 0x204D, 0x204E, 0x204F,
- /* 5 */ 0x2050, 0x2051, 0x2052, 0x2053, 0x2054, 0x2055, 0x2056, 0x2057,
- 0x2058, 0x2059, 0x205A, 0x205B, 0x205C, 0x205D, 0x205E, 0x205F,
- /* 6 */ 0x2060, 0x2061, 0x2062, 0x2063, 0x2064, 0x2065, 0x2066, 0x2067,
- 0x2068, 0x2069, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
- /* 7 */ 0x2070, 0x2071, 0x2072, 0x2073, 0x2074, 0x2075, 0x2076, 0x2077,
- 0x2078, 0x2079, 0x207A, 0x207B, 0x207C, 0x207D, 0x207E, 0x207F,
- /* 8 */ 0x2080, 0x2081, 0x2082, 0x2083, 0x2084, 0x2085, 0x2086, 0x2087,
- 0x2088, 0x2089, 0x208A, 0x208B, 0x208C, 0x208D, 0x208E, 0x208F,
- /* 9 */ 0x2090, 0x2091, 0x2092, 0x2093, 0x2094, 0x2095, 0x2096, 0x2097,
- 0x2098, 0x2099, 0x209A, 0x209B, 0x209C, 0x209D, 0x209E, 0x209F,
- /* A */ 0x20A0, 0x20A1, 0x20A2, 0x20A3, 0x20A4, 0x20A5, 0x20A6, 0x20A7,
- 0x20A8, 0x20A9, 0x20AA, 0x20AB, 0x20AC, 0x20AD, 0x20AE, 0x20AF,
- /* B */ 0x20B0, 0x20B1, 0x20B2, 0x20B3, 0x20B4, 0x20B5, 0x20B6, 0x20B7,
- 0x20B8, 0x20B9, 0x20BA, 0x20BB, 0x20BC, 0x20BD, 0x20BE, 0x20BF,
- /* C */ 0x20C0, 0x20C1, 0x20C2, 0x20C3, 0x20C4, 0x20C5, 0x20C6, 0x20C7,
- 0x20C8, 0x20C9, 0x20CA, 0x20CB, 0x20CC, 0x20CD, 0x20CE, 0x20CF,
- /* D */ 0x20D0, 0x20D1, 0x20D2, 0x20D3, 0x20D4, 0x20D5, 0x20D6, 0x20D7,
- 0x20D8, 0x20D9, 0x20DA, 0x20DB, 0x20DC, 0x20DD, 0x20DE, 0x20DF,
- /* E */ 0x20E0, 0x20E1, 0x20E2, 0x20E3, 0x20E4, 0x20E5, 0x20E6, 0x20E7,
- 0x20E8, 0x20E9, 0x20EA, 0x20EB, 0x20EC, 0x20ED, 0x20EE, 0x20EF,
- /* F */ 0x20F0, 0x20F1, 0x20F2, 0x20F3, 0x20F4, 0x20F5, 0x20F6, 0x20F7,
- 0x20F8, 0x20F9, 0x20FA, 0x20FB, 0x20FC, 0x20FD, 0x20FE, 0x20FF,
+ /* 0 */ 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007,
+ 0x2008, 0x2009, 0x200A, 0x200B, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 1 */ 0x2010, 0x2011, 0x2012, 0x2013, 0x2014, 0x2015, 0x2016, 0x2017,
+ 0x2018, 0x2019, 0x201A, 0x201B, 0x201C, 0x201D, 0x201E, 0x201F,
+ /* 2 */ 0x2020, 0x2021, 0x2022, 0x2023, 0x2024, 0x2025, 0x2026, 0x2027,
+ 0x2028, 0x2029, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x202F,
+ /* 3 */ 0x2030, 0x2031, 0x2032, 0x2033, 0x2034, 0x2035, 0x2036, 0x2037,
+ 0x2038, 0x2039, 0x203A, 0x203B, 0x203C, 0x203D, 0x203E, 0x203F,
+ /* 4 */ 0x2040, 0x2041, 0x2042, 0x2043, 0x2044, 0x2045, 0x2046, 0x2047,
+ 0x2048, 0x2049, 0x204A, 0x204B, 0x204C, 0x204D, 0x204E, 0x204F,
+ /* 5 */ 0x2050, 0x2051, 0x2052, 0x2053, 0x2054, 0x2055, 0x2056, 0x2057,
+ 0x2058, 0x2059, 0x205A, 0x205B, 0x205C, 0x205D, 0x205E, 0x205F,
+ /* 6 */ 0x2060, 0x2061, 0x2062, 0x2063, 0x2064, 0x2065, 0x2066, 0x2067,
+ 0x2068, 0x2069, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ /* 7 */ 0x2070, 0x2071, 0x2072, 0x2073, 0x2074, 0x2075, 0x2076, 0x2077,
+ 0x2078, 0x2079, 0x207A, 0x207B, 0x207C, 0x207D, 0x207E, 0x207F,
+ /* 8 */ 0x2080, 0x2081, 0x2082, 0x2083, 0x2084, 0x2085, 0x2086, 0x2087,
+ 0x2088, 0x2089, 0x208A, 0x208B, 0x208C, 0x208D, 0x208E, 0x208F,
+ /* 9 */ 0x2090, 0x2091, 0x2092, 0x2093, 0x2094, 0x2095, 0x2096, 0x2097,
+ 0x2098, 0x2099, 0x209A, 0x209B, 0x209C, 0x209D, 0x209E, 0x209F,
+ /* A */ 0x20A0, 0x20A1, 0x20A2, 0x20A3, 0x20A4, 0x20A5, 0x20A6, 0x20A7,
+ 0x20A8, 0x20A9, 0x20AA, 0x20AB, 0x20AC, 0x20AD, 0x20AE, 0x20AF,
+ /* B */ 0x20B0, 0x20B1, 0x20B2, 0x20B3, 0x20B4, 0x20B5, 0x20B6, 0x20B7,
+ 0x20B8, 0x20B9, 0x20BA, 0x20BB, 0x20BC, 0x20BD, 0x20BE, 0x20BF,
+ /* C */ 0x20C0, 0x20C1, 0x20C2, 0x20C3, 0x20C4, 0x20C5, 0x20C6, 0x20C7,
+ 0x20C8, 0x20C9, 0x20CA, 0x20CB, 0x20CC, 0x20CD, 0x20CE, 0x20CF,
+ /* D */ 0x20D0, 0x20D1, 0x20D2, 0x20D3, 0x20D4, 0x20D5, 0x20D6, 0x20D7,
+ 0x20D8, 0x20D9, 0x20DA, 0x20DB, 0x20DC, 0x20DD, 0x20DE, 0x20DF,
+ /* E */ 0x20E0, 0x20E1, 0x20E2, 0x20E3, 0x20E4, 0x20E5, 0x20E6, 0x20E7,
+ 0x20E8, 0x20E9, 0x20EA, 0x20EB, 0x20EC, 0x20ED, 0x20EE, 0x20EF,
+ /* F */ 0x20F0, 0x20F1, 0x20F2, 0x20F3, 0x20F4, 0x20F5, 0x20F6, 0x20F7,
+ 0x20F8, 0x20F9, 0x20FA, 0x20FB, 0x20FC, 0x20FD, 0x20FE, 0x20FF,
- // Table 8 (for high byte 0x21)
+ // Table 8 (for high byte 0x21)
- /* 0 */ 0x2100, 0x2101, 0x2102, 0x2103, 0x2104, 0x2105, 0x2106, 0x2107,
- 0x2108, 0x2109, 0x210A, 0x210B, 0x210C, 0x210D, 0x210E, 0x210F,
- /* 1 */ 0x2110, 0x2111, 0x2112, 0x2113, 0x2114, 0x2115, 0x2116, 0x2117,
- 0x2118, 0x2119, 0x211A, 0x211B, 0x211C, 0x211D, 0x211E, 0x211F,
- /* 2 */ 0x2120, 0x2121, 0x2122, 0x2123, 0x2124, 0x2125, 0x2126, 0x2127,
- 0x2128, 0x2129, 0x212A, 0x212B, 0x212C, 0x212D, 0x212E, 0x212F,
- /* 3 */ 0x2130, 0x2131, 0x2132, 0x2133, 0x2134, 0x2135, 0x2136, 0x2137,
- 0x2138, 0x2139, 0x213A, 0x213B, 0x213C, 0x213D, 0x213E, 0x213F,
- /* 4 */ 0x2140, 0x2141, 0x2142, 0x2143, 0x2144, 0x2145, 0x2146, 0x2147,
- 0x2148, 0x2149, 0x214A, 0x214B, 0x214C, 0x214D, 0x214E, 0x214F,
- /* 5 */ 0x2150, 0x2151, 0x2152, 0x2153, 0x2154, 0x2155, 0x2156, 0x2157,
- 0x2158, 0x2159, 0x215A, 0x215B, 0x215C, 0x215D, 0x215E, 0x215F,
- /* 6 */ 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177,
- 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F,
- /* 7 */ 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177,
- 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F,
- /* 8 */ 0x2180, 0x2181, 0x2182, 0x2183, 0x2184, 0x2185, 0x2186, 0x2187,
- 0x2188, 0x2189, 0x218A, 0x218B, 0x218C, 0x218D, 0x218E, 0x218F,
- /* 9 */ 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x2195, 0x2196, 0x2197,
- 0x2198, 0x2199, 0x219A, 0x219B, 0x219C, 0x219D, 0x219E, 0x219F,
- /* A */ 0x21A0, 0x21A1, 0x21A2, 0x21A3, 0x21A4, 0x21A5, 0x21A6, 0x21A7,
- 0x21A8, 0x21A9, 0x21AA, 0x21AB, 0x21AC, 0x21AD, 0x21AE, 0x21AF,
- /* B */ 0x21B0, 0x21B1, 0x21B2, 0x21B3, 0x21B4, 0x21B5, 0x21B6, 0x21B7,
- 0x21B8, 0x21B9, 0x21BA, 0x21BB, 0x21BC, 0x21BD, 0x21BE, 0x21BF,
- /* C */ 0x21C0, 0x21C1, 0x21C2, 0x21C3, 0x21C4, 0x21C5, 0x21C6, 0x21C7,
- 0x21C8, 0x21C9, 0x21CA, 0x21CB, 0x21CC, 0x21CD, 0x21CE, 0x21CF,
- /* D */ 0x21D0, 0x21D1, 0x21D2, 0x21D3, 0x21D4, 0x21D5, 0x21D6, 0x21D7,
- 0x21D8, 0x21D9, 0x21DA, 0x21DB, 0x21DC, 0x21DD, 0x21DE, 0x21DF,
- /* E */ 0x21E0, 0x21E1, 0x21E2, 0x21E3, 0x21E4, 0x21E5, 0x21E6, 0x21E7,
- 0x21E8, 0x21E9, 0x21EA, 0x21EB, 0x21EC, 0x21ED, 0x21EE, 0x21EF,
- /* F */ 0x21F0, 0x21F1, 0x21F2, 0x21F3, 0x21F4, 0x21F5, 0x21F6, 0x21F7,
- 0x21F8, 0x21F9, 0x21FA, 0x21FB, 0x21FC, 0x21FD, 0x21FE, 0x21FF,
+ /* 0 */ 0x2100, 0x2101, 0x2102, 0x2103, 0x2104, 0x2105, 0x2106, 0x2107,
+ 0x2108, 0x2109, 0x210A, 0x210B, 0x210C, 0x210D, 0x210E, 0x210F,
+ /* 1 */ 0x2110, 0x2111, 0x2112, 0x2113, 0x2114, 0x2115, 0x2116, 0x2117,
+ 0x2118, 0x2119, 0x211A, 0x211B, 0x211C, 0x211D, 0x211E, 0x211F,
+ /* 2 */ 0x2120, 0x2121, 0x2122, 0x2123, 0x2124, 0x2125, 0x2126, 0x2127,
+ 0x2128, 0x2129, 0x212A, 0x212B, 0x212C, 0x212D, 0x212E, 0x212F,
+ /* 3 */ 0x2130, 0x2131, 0x2132, 0x2133, 0x2134, 0x2135, 0x2136, 0x2137,
+ 0x2138, 0x2139, 0x213A, 0x213B, 0x213C, 0x213D, 0x213E, 0x213F,
+ /* 4 */ 0x2140, 0x2141, 0x2142, 0x2143, 0x2144, 0x2145, 0x2146, 0x2147,
+ 0x2148, 0x2149, 0x214A, 0x214B, 0x214C, 0x214D, 0x214E, 0x214F,
+ /* 5 */ 0x2150, 0x2151, 0x2152, 0x2153, 0x2154, 0x2155, 0x2156, 0x2157,
+ 0x2158, 0x2159, 0x215A, 0x215B, 0x215C, 0x215D, 0x215E, 0x215F,
+ /* 6 */ 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177,
+ 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F,
+ /* 7 */ 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177,
+ 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F,
+ /* 8 */ 0x2180, 0x2181, 0x2182, 0x2183, 0x2184, 0x2185, 0x2186, 0x2187,
+ 0x2188, 0x2189, 0x218A, 0x218B, 0x218C, 0x218D, 0x218E, 0x218F,
+ /* 9 */ 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x2195, 0x2196, 0x2197,
+ 0x2198, 0x2199, 0x219A, 0x219B, 0x219C, 0x219D, 0x219E, 0x219F,
+ /* A */ 0x21A0, 0x21A1, 0x21A2, 0x21A3, 0x21A4, 0x21A5, 0x21A6, 0x21A7,
+ 0x21A8, 0x21A9, 0x21AA, 0x21AB, 0x21AC, 0x21AD, 0x21AE, 0x21AF,
+ /* B */ 0x21B0, 0x21B1, 0x21B2, 0x21B3, 0x21B4, 0x21B5, 0x21B6, 0x21B7,
+ 0x21B8, 0x21B9, 0x21BA, 0x21BB, 0x21BC, 0x21BD, 0x21BE, 0x21BF,
+ /* C */ 0x21C0, 0x21C1, 0x21C2, 0x21C3, 0x21C4, 0x21C5, 0x21C6, 0x21C7,
+ 0x21C8, 0x21C9, 0x21CA, 0x21CB, 0x21CC, 0x21CD, 0x21CE, 0x21CF,
+ /* D */ 0x21D0, 0x21D1, 0x21D2, 0x21D3, 0x21D4, 0x21D5, 0x21D6, 0x21D7,
+ 0x21D8, 0x21D9, 0x21DA, 0x21DB, 0x21DC, 0x21DD, 0x21DE, 0x21DF,
+ /* E */ 0x21E0, 0x21E1, 0x21E2, 0x21E3, 0x21E4, 0x21E5, 0x21E6, 0x21E7,
+ 0x21E8, 0x21E9, 0x21EA, 0x21EB, 0x21EC, 0x21ED, 0x21EE, 0x21EF,
+ /* F */ 0x21F0, 0x21F1, 0x21F2, 0x21F3, 0x21F4, 0x21F5, 0x21F6, 0x21F7,
+ 0x21F8, 0x21F9, 0x21FA, 0x21FB, 0x21FC, 0x21FD, 0x21FE, 0x21FF,
- // Table 9 (for high byte 0xFE)
+ // Table 9 (for high byte 0xFE)
- /* 0 */ 0xFE00, 0xFE01, 0xFE02, 0xFE03, 0xFE04, 0xFE05, 0xFE06, 0xFE07,
- 0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F,
- /* 1 */ 0xFE10, 0xFE11, 0xFE12, 0xFE13, 0xFE14, 0xFE15, 0xFE16, 0xFE17,
- 0xFE18, 0xFE19, 0xFE1A, 0xFE1B, 0xFE1C, 0xFE1D, 0xFE1E, 0xFE1F,
- /* 2 */ 0xFE20, 0xFE21, 0xFE22, 0xFE23, 0xFE24, 0xFE25, 0xFE26, 0xFE27,
- 0xFE28, 0xFE29, 0xFE2A, 0xFE2B, 0xFE2C, 0xFE2D, 0xFE2E, 0xFE2F,
- /* 3 */ 0xFE30, 0xFE31, 0xFE32, 0xFE33, 0xFE34, 0xFE35, 0xFE36, 0xFE37,
- 0xFE38, 0xFE39, 0xFE3A, 0xFE3B, 0xFE3C, 0xFE3D, 0xFE3E, 0xFE3F,
- /* 4 */ 0xFE40, 0xFE41, 0xFE42, 0xFE43, 0xFE44, 0xFE45, 0xFE46, 0xFE47,
- 0xFE48, 0xFE49, 0xFE4A, 0xFE4B, 0xFE4C, 0xFE4D, 0xFE4E, 0xFE4F,
- /* 5 */ 0xFE50, 0xFE51, 0xFE52, 0xFE53, 0xFE54, 0xFE55, 0xFE56, 0xFE57,
- 0xFE58, 0xFE59, 0xFE5A, 0xFE5B, 0xFE5C, 0xFE5D, 0xFE5E, 0xFE5F,
- /* 6 */ 0xFE60, 0xFE61, 0xFE62, 0xFE63, 0xFE64, 0xFE65, 0xFE66, 0xFE67,
- 0xFE68, 0xFE69, 0xFE6A, 0xFE6B, 0xFE6C, 0xFE6D, 0xFE6E, 0xFE6F,
- /* 7 */ 0xFE70, 0xFE71, 0xFE72, 0xFE73, 0xFE74, 0xFE75, 0xFE76, 0xFE77,
- 0xFE78, 0xFE79, 0xFE7A, 0xFE7B, 0xFE7C, 0xFE7D, 0xFE7E, 0xFE7F,
- /* 8 */ 0xFE80, 0xFE81, 0xFE82, 0xFE83, 0xFE84, 0xFE85, 0xFE86, 0xFE87,
- 0xFE88, 0xFE89, 0xFE8A, 0xFE8B, 0xFE8C, 0xFE8D, 0xFE8E, 0xFE8F,
- /* 9 */ 0xFE90, 0xFE91, 0xFE92, 0xFE93, 0xFE94, 0xFE95, 0xFE96, 0xFE97,
- 0xFE98, 0xFE99, 0xFE9A, 0xFE9B, 0xFE9C, 0xFE9D, 0xFE9E, 0xFE9F,
- /* A */ 0xFEA0, 0xFEA1, 0xFEA2, 0xFEA3, 0xFEA4, 0xFEA5, 0xFEA6, 0xFEA7,
- 0xFEA8, 0xFEA9, 0xFEAA, 0xFEAB, 0xFEAC, 0xFEAD, 0xFEAE, 0xFEAF,
- /* B */ 0xFEB0, 0xFEB1, 0xFEB2, 0xFEB3, 0xFEB4, 0xFEB5, 0xFEB6, 0xFEB7,
- 0xFEB8, 0xFEB9, 0xFEBA, 0xFEBB, 0xFEBC, 0xFEBD, 0xFEBE, 0xFEBF,
- /* C */ 0xFEC0, 0xFEC1, 0xFEC2, 0xFEC3, 0xFEC4, 0xFEC5, 0xFEC6, 0xFEC7,
- 0xFEC8, 0xFEC9, 0xFECA, 0xFECB, 0xFECC, 0xFECD, 0xFECE, 0xFECF,
- /* D */ 0xFED0, 0xFED1, 0xFED2, 0xFED3, 0xFED4, 0xFED5, 0xFED6, 0xFED7,
- 0xFED8, 0xFED9, 0xFEDA, 0xFEDB, 0xFEDC, 0xFEDD, 0xFEDE, 0xFEDF,
- /* E */ 0xFEE0, 0xFEE1, 0xFEE2, 0xFEE3, 0xFEE4, 0xFEE5, 0xFEE6, 0xFEE7,
- 0xFEE8, 0xFEE9, 0xFEEA, 0xFEEB, 0xFEEC, 0xFEED, 0xFEEE, 0xFEEF,
- /* F */ 0xFEF0, 0xFEF1, 0xFEF2, 0xFEF3, 0xFEF4, 0xFEF5, 0xFEF6, 0xFEF7,
- 0xFEF8, 0xFEF9, 0xFEFA, 0xFEFB, 0xFEFC, 0xFEFD, 0xFEFE, 0x0000,
+ /* 0 */ 0xFE00, 0xFE01, 0xFE02, 0xFE03, 0xFE04, 0xFE05, 0xFE06, 0xFE07,
+ 0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F,
+ /* 1 */ 0xFE10, 0xFE11, 0xFE12, 0xFE13, 0xFE14, 0xFE15, 0xFE16, 0xFE17,
+ 0xFE18, 0xFE19, 0xFE1A, 0xFE1B, 0xFE1C, 0xFE1D, 0xFE1E, 0xFE1F,
+ /* 2 */ 0xFE20, 0xFE21, 0xFE22, 0xFE23, 0xFE24, 0xFE25, 0xFE26, 0xFE27,
+ 0xFE28, 0xFE29, 0xFE2A, 0xFE2B, 0xFE2C, 0xFE2D, 0xFE2E, 0xFE2F,
+ /* 3 */ 0xFE30, 0xFE31, 0xFE32, 0xFE33, 0xFE34, 0xFE35, 0xFE36, 0xFE37,
+ 0xFE38, 0xFE39, 0xFE3A, 0xFE3B, 0xFE3C, 0xFE3D, 0xFE3E, 0xFE3F,
+ /* 4 */ 0xFE40, 0xFE41, 0xFE42, 0xFE43, 0xFE44, 0xFE45, 0xFE46, 0xFE47,
+ 0xFE48, 0xFE49, 0xFE4A, 0xFE4B, 0xFE4C, 0xFE4D, 0xFE4E, 0xFE4F,
+ /* 5 */ 0xFE50, 0xFE51, 0xFE52, 0xFE53, 0xFE54, 0xFE55, 0xFE56, 0xFE57,
+ 0xFE58, 0xFE59, 0xFE5A, 0xFE5B, 0xFE5C, 0xFE5D, 0xFE5E, 0xFE5F,
+ /* 6 */ 0xFE60, 0xFE61, 0xFE62, 0xFE63, 0xFE64, 0xFE65, 0xFE66, 0xFE67,
+ 0xFE68, 0xFE69, 0xFE6A, 0xFE6B, 0xFE6C, 0xFE6D, 0xFE6E, 0xFE6F,
+ /* 7 */ 0xFE70, 0xFE71, 0xFE72, 0xFE73, 0xFE74, 0xFE75, 0xFE76, 0xFE77,
+ 0xFE78, 0xFE79, 0xFE7A, 0xFE7B, 0xFE7C, 0xFE7D, 0xFE7E, 0xFE7F,
+ /* 8 */ 0xFE80, 0xFE81, 0xFE82, 0xFE83, 0xFE84, 0xFE85, 0xFE86, 0xFE87,
+ 0xFE88, 0xFE89, 0xFE8A, 0xFE8B, 0xFE8C, 0xFE8D, 0xFE8E, 0xFE8F,
+ /* 9 */ 0xFE90, 0xFE91, 0xFE92, 0xFE93, 0xFE94, 0xFE95, 0xFE96, 0xFE97,
+ 0xFE98, 0xFE99, 0xFE9A, 0xFE9B, 0xFE9C, 0xFE9D, 0xFE9E, 0xFE9F,
+ /* A */ 0xFEA0, 0xFEA1, 0xFEA2, 0xFEA3, 0xFEA4, 0xFEA5, 0xFEA6, 0xFEA7,
+ 0xFEA8, 0xFEA9, 0xFEAA, 0xFEAB, 0xFEAC, 0xFEAD, 0xFEAE, 0xFEAF,
+ /* B */ 0xFEB0, 0xFEB1, 0xFEB2, 0xFEB3, 0xFEB4, 0xFEB5, 0xFEB6, 0xFEB7,
+ 0xFEB8, 0xFEB9, 0xFEBA, 0xFEBB, 0xFEBC, 0xFEBD, 0xFEBE, 0xFEBF,
+ /* C */ 0xFEC0, 0xFEC1, 0xFEC2, 0xFEC3, 0xFEC4, 0xFEC5, 0xFEC6, 0xFEC7,
+ 0xFEC8, 0xFEC9, 0xFECA, 0xFECB, 0xFECC, 0xFECD, 0xFECE, 0xFECF,
+ /* D */ 0xFED0, 0xFED1, 0xFED2, 0xFED3, 0xFED4, 0xFED5, 0xFED6, 0xFED7,
+ 0xFED8, 0xFED9, 0xFEDA, 0xFEDB, 0xFEDC, 0xFEDD, 0xFEDE, 0xFEDF,
+ /* E */ 0xFEE0, 0xFEE1, 0xFEE2, 0xFEE3, 0xFEE4, 0xFEE5, 0xFEE6, 0xFEE7,
+ 0xFEE8, 0xFEE9, 0xFEEA, 0xFEEB, 0xFEEC, 0xFEED, 0xFEEE, 0xFEEF,
+ /* F */ 0xFEF0, 0xFEF1, 0xFEF2, 0xFEF3, 0xFEF4, 0xFEF5, 0xFEF6, 0xFEF7,
+ 0xFEF8, 0xFEF9, 0xFEFA, 0xFEFB, 0xFEFC, 0xFEFD, 0xFEFE, 0x0000,
- // Table 10 (for high byte 0xFF)
+ // Table 10 (for high byte 0xFF)
- /* 0 */ 0xFF00, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07,
- 0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F,
- /* 1 */ 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17,
- 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F,
- /* 2 */ 0xFF20, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47,
- 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F,
- /* 3 */ 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57,
- 0xFF58, 0xFF59, 0xFF5A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F,
- /* 4 */ 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47,
- 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F,
- /* 5 */ 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57,
- 0xFF58, 0xFF59, 0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E, 0xFF5F,
- /* 6 */ 0xFF60, 0xFF61, 0xFF62, 0xFF63, 0xFF64, 0xFF65, 0xFF66, 0xFF67,
- 0xFF68, 0xFF69, 0xFF6A, 0xFF6B, 0xFF6C, 0xFF6D, 0xFF6E, 0xFF6F,
- /* 7 */ 0xFF70, 0xFF71, 0xFF72, 0xFF73, 0xFF74, 0xFF75, 0xFF76, 0xFF77,
- 0xFF78, 0xFF79, 0xFF7A, 0xFF7B, 0xFF7C, 0xFF7D, 0xFF7E, 0xFF7F,
- /* 8 */ 0xFF80, 0xFF81, 0xFF82, 0xFF83, 0xFF84, 0xFF85, 0xFF86, 0xFF87,
- 0xFF88, 0xFF89, 0xFF8A, 0xFF8B, 0xFF8C, 0xFF8D, 0xFF8E, 0xFF8F,
- /* 9 */ 0xFF90, 0xFF91, 0xFF92, 0xFF93, 0xFF94, 0xFF95, 0xFF96, 0xFF97,
- 0xFF98, 0xFF99, 0xFF9A, 0xFF9B, 0xFF9C, 0xFF9D, 0xFF9E, 0xFF9F,
- /* A */ 0xFFA0, 0xFFA1, 0xFFA2, 0xFFA3, 0xFFA4, 0xFFA5, 0xFFA6, 0xFFA7,
- 0xFFA8, 0xFFA9, 0xFFAA, 0xFFAB, 0xFFAC, 0xFFAD, 0xFFAE, 0xFFAF,
- /* B */ 0xFFB0, 0xFFB1, 0xFFB2, 0xFFB3, 0xFFB4, 0xFFB5, 0xFFB6, 0xFFB7,
- 0xFFB8, 0xFFB9, 0xFFBA, 0xFFBB, 0xFFBC, 0xFFBD, 0xFFBE, 0xFFBF,
- /* C */ 0xFFC0, 0xFFC1, 0xFFC2, 0xFFC3, 0xFFC4, 0xFFC5, 0xFFC6, 0xFFC7,
- 0xFFC8, 0xFFC9, 0xFFCA, 0xFFCB, 0xFFCC, 0xFFCD, 0xFFCE, 0xFFCF,
- /* D */ 0xFFD0, 0xFFD1, 0xFFD2, 0xFFD3, 0xFFD4, 0xFFD5, 0xFFD6, 0xFFD7,
- 0xFFD8, 0xFFD9, 0xFFDA, 0xFFDB, 0xFFDC, 0xFFDD, 0xFFDE, 0xFFDF,
- /* E */ 0xFFE0, 0xFFE1, 0xFFE2, 0xFFE3, 0xFFE4, 0xFFE5, 0xFFE6, 0xFFE7,
- 0xFFE8, 0xFFE9, 0xFFEA, 0xFFEB, 0xFFEC, 0xFFED, 0xFFEE, 0xFFEF,
- /* F */ 0xFFF0, 0xFFF1, 0xFFF2, 0xFFF3, 0xFFF4, 0xFFF5, 0xFFF6, 0xFFF7,
- 0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF,
+ /* 0 */ 0xFF00, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07,
+ 0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F,
+ /* 1 */ 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17,
+ 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F,
+ /* 2 */ 0xFF20, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47,
+ 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F,
+ /* 3 */ 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57,
+ 0xFF58, 0xFF59, 0xFF5A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F,
+ /* 4 */ 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47,
+ 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F,
+ /* 5 */ 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57,
+ 0xFF58, 0xFF59, 0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E, 0xFF5F,
+ /* 6 */ 0xFF60, 0xFF61, 0xFF62, 0xFF63, 0xFF64, 0xFF65, 0xFF66, 0xFF67,
+ 0xFF68, 0xFF69, 0xFF6A, 0xFF6B, 0xFF6C, 0xFF6D, 0xFF6E, 0xFF6F,
+ /* 7 */ 0xFF70, 0xFF71, 0xFF72, 0xFF73, 0xFF74, 0xFF75, 0xFF76, 0xFF77,
+ 0xFF78, 0xFF79, 0xFF7A, 0xFF7B, 0xFF7C, 0xFF7D, 0xFF7E, 0xFF7F,
+ /* 8 */ 0xFF80, 0xFF81, 0xFF82, 0xFF83, 0xFF84, 0xFF85, 0xFF86, 0xFF87,
+ 0xFF88, 0xFF89, 0xFF8A, 0xFF8B, 0xFF8C, 0xFF8D, 0xFF8E, 0xFF8F,
+ /* 9 */ 0xFF90, 0xFF91, 0xFF92, 0xFF93, 0xFF94, 0xFF95, 0xFF96, 0xFF97,
+ 0xFF98, 0xFF99, 0xFF9A, 0xFF9B, 0xFF9C, 0xFF9D, 0xFF9E, 0xFF9F,
+ /* A */ 0xFFA0, 0xFFA1, 0xFFA2, 0xFFA3, 0xFFA4, 0xFFA5, 0xFFA6, 0xFFA7,
+ 0xFFA8, 0xFFA9, 0xFFAA, 0xFFAB, 0xFFAC, 0xFFAD, 0xFFAE, 0xFFAF,
+ /* B */ 0xFFB0, 0xFFB1, 0xFFB2, 0xFFB3, 0xFFB4, 0xFFB5, 0xFFB6, 0xFFB7,
+ 0xFFB8, 0xFFB9, 0xFFBA, 0xFFBB, 0xFFBC, 0xFFBD, 0xFFBE, 0xFFBF,
+ /* C */ 0xFFC0, 0xFFC1, 0xFFC2, 0xFFC3, 0xFFC4, 0xFFC5, 0xFFC6, 0xFFC7,
+ 0xFFC8, 0xFFC9, 0xFFCA, 0xFFCB, 0xFFCC, 0xFFCD, 0xFFCE, 0xFFCF,
+ /* D */ 0xFFD0, 0xFFD1, 0xFFD2, 0xFFD3, 0xFFD4, 0xFFD5, 0xFFD6, 0xFFD7,
+ 0xFFD8, 0xFFD9, 0xFFDA, 0xFFDB, 0xFFDC, 0xFFDD, 0xFFDE, 0xFFDF,
+ /* E */ 0xFFE0, 0xFFE1, 0xFFE2, 0xFFE3, 0xFFE4, 0xFFE5, 0xFFE6, 0xFFE7,
+ 0xFFE8, 0xFFE9, 0xFFEA, 0xFFEB, 0xFFEC, 0xFFED, 0xFFEE, 0xFFEF,
+ /* F */ 0xFFF0, 0xFFF1, 0xFFF2, 0xFFF3, 0xFFF4, 0xFFF5, 0xFFF6, 0xFFF7,
+ 0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF,
};
// Returns the next non-ignorable codepoint within string starting from the
@@ -1157,12 +1152,10 @@
int index2 = 0;
for (;;) {
- int codepoint1 = HFSReadNextNonIgnorableCodepoint(string1.data(),
- length1,
- &index1);
- int codepoint2 = HFSReadNextNonIgnorableCodepoint(string2.data(),
- length2,
- &index2);
+ int codepoint1 =
+ HFSReadNextNonIgnorableCodepoint(string1.data(), length1, &index1);
+ int codepoint2 =
+ HFSReadNextNonIgnorableCodepoint(string2.data(), length2, &index2);
if (codepoint1 != codepoint2)
return (codepoint1 < codepoint2) ? -1 : 1;
if (codepoint1 == 0) {
@@ -1175,14 +1168,9 @@
StringType FilePath::GetHFSDecomposedForm(StringPieceType string) {
StringType result;
- ScopedCFTypeRef<CFStringRef> cfstring(
- CFStringCreateWithBytesNoCopy(
- NULL,
- reinterpret_cast<const UInt8*>(string.data()),
- string.length(),
- kCFStringEncodingUTF8,
- false,
- kCFAllocatorNull));
+ ScopedCFTypeRef<CFStringRef> cfstring(CFStringCreateWithBytesNoCopy(
+ NULL, reinterpret_cast<const UInt8*>(string.data()), string.length(),
+ kCFStringEncodingUTF8, false, kCFAllocatorNull));
if (cfstring) {
// Query the maximum length needed to store the result. In most cases this
// will overestimate the required space. The return value also already
@@ -1194,9 +1182,8 @@
// (Increasing rather than decreasing it would clobber the string contents!)
result.reserve(length);
result.resize(length - 1);
- Boolean success = CFStringGetFileSystemRepresentation(cfstring,
- &result[0],
- length);
+ Boolean success =
+ CFStringGetFileSystemRepresentation(cfstring, &result[0], length);
if (success) {
// Reduce result.length() to actual string length.
result.resize(strlen(result.c_str()));
@@ -1223,25 +1210,13 @@
// GetHFSDecomposedForm() returns an empty string in an error case.
if (hfs1.empty() || hfs2.empty()) {
NOTREACHED();
- ScopedCFTypeRef<CFStringRef> cfstring1(
- CFStringCreateWithBytesNoCopy(
- NULL,
- reinterpret_cast<const UInt8*>(string1.data()),
- string1.length(),
- kCFStringEncodingUTF8,
- false,
- kCFAllocatorNull));
- ScopedCFTypeRef<CFStringRef> cfstring2(
- CFStringCreateWithBytesNoCopy(
- NULL,
- reinterpret_cast<const UInt8*>(string2.data()),
- string2.length(),
- kCFStringEncodingUTF8,
- false,
- kCFAllocatorNull));
- return CFStringCompare(cfstring1,
- cfstring2,
- kCFCompareCaseInsensitive);
+ ScopedCFTypeRef<CFStringRef> cfstring1(CFStringCreateWithBytesNoCopy(
+ NULL, reinterpret_cast<const UInt8*>(string1.data()), string1.length(),
+ kCFStringEncodingUTF8, false, kCFAllocatorNull));
+ ScopedCFTypeRef<CFStringRef> cfstring2(CFStringCreateWithBytesNoCopy(
+ NULL, reinterpret_cast<const UInt8*>(string2.data()), string2.length(),
+ kCFStringEncodingUTF8, false, kCFAllocatorNull));
+ return CFStringCompare(cfstring1, cfstring2, kCFCompareCaseInsensitive);
}
return HFSFastUnicodeCompare(hfs1, hfs2);
@@ -1253,8 +1228,8 @@
int FilePath::CompareIgnoreCase(StringPieceType string1,
StringPieceType string2) {
// Specifically need null termianted strings for this API call.
- int comparison = strcasecmp(string1.as_string().c_str(),
- string2.as_string().c_str());
+ int comparison =
+ strcasecmp(string1.as_string().c_str(), string2.as_string().c_str());
if (comparison < 0)
return -1;
if (comparison > 0)
@@ -1264,7 +1239,6 @@
#endif // OS versions of CompareIgnoreCase()
-
void FilePath::StripTrailingSeparatorsInternal() {
// If there is no drive letter, start will be 1, which will prevent stripping
// the leading separator if there is only one separator. If there is a drive
@@ -1275,8 +1249,7 @@
StringType::size_type last_stripped = StringType::npos;
for (StringType::size_type pos = path_.length();
- pos > start && IsSeparator(path_[pos - 1]);
- --pos) {
+ pos > start && IsSeparator(path_[pos - 1]); --pos) {
// If the string only has two separators and they're at the beginning,
// don't strip them, unless the string began with more than two separators.
if (pos != start + 1 || last_stripped == start + 2 ||
diff --git a/base/files/file_path.h b/base/files/file_path.h
index 8c153b4..63b21e8 100644
--- a/base/files/file_path.h
+++ b/base/files/file_path.h
@@ -191,9 +191,7 @@
bool operator!=(const FilePath& that) const;
// Required for some STL containers and operations
- bool operator<(const FilePath& that) const {
- return path_ < that.path_;
- }
+ bool operator<(const FilePath& that) const { return path_ < that.path_; }
const StringType& value() const { return path_; }
@@ -284,10 +282,10 @@
// path == "jojo.jpg" suffix == " (1)", returns "jojo (1).jpg"
// path == "C:\pics\jojo" suffix == " (1)", returns "C:\pics\jojo (1)"
// path == "C:\pics.old\jojo" suffix == " (1)", returns "C:\pics.old\jojo (1)"
- FilePath InsertBeforeExtension(
- StringPieceType suffix) const WARN_UNUSED_RESULT;
- FilePath InsertBeforeExtensionASCII(
- StringPiece suffix) const WARN_UNUSED_RESULT;
+ FilePath InsertBeforeExtension(StringPieceType suffix) const
+ WARN_UNUSED_RESULT;
+ FilePath InsertBeforeExtensionASCII(StringPiece suffix) const
+ WARN_UNUSED_RESULT;
// Adds |extension| to |file_name|. Returns the current FilePath if
// |extension| is empty. Returns "" if BaseName() == "." or "..".
@@ -437,15 +435,14 @@
StringType path_;
};
-std::ostream& operator<<(std::ostream& out,
- const FilePath& file_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.
#if defined(OS_WIN)
-#define FILE_PATH_LITERAL(x) L ## x
+#define FILE_PATH_LITERAL(x) L##x
#define PRFilePath "ls"
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
#define FILE_PATH_LITERAL(x) x
diff --git a/base/files/file_path_constants.cc b/base/files/file_path_constants.cc
index 0b74846..fc7d663 100644
--- a/base/files/file_path_constants.cc
+++ b/base/files/file_path_constants.cc
@@ -11,7 +11,7 @@
#if defined(FILE_PATH_USES_WIN_SEPARATORS)
const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("\\/");
-#else // FILE_PATH_USES_WIN_SEPARATORS
+#else // FILE_PATH_USES_WIN_SEPARATORS
const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("/");
#endif // FILE_PATH_USES_WIN_SEPARATORS
diff --git a/base/files/file_posix.cc b/base/files/file_posix.cc
index 344621f..fcc10c6 100644
--- a/base/files/file_posix.cc
+++ b/base/files/file_posix.cc
@@ -26,11 +26,11 @@
#if defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL) || \
defined(OS_ANDROID) && __ANDROID_API__ < 21
-int CallFstat(int fd, stat_wrapper_t *sb) {
+int CallFstat(int fd, stat_wrapper_t* sb) {
return fstat(fd, sb);
}
#else
-int CallFstat(int fd, stat_wrapper_t *sb) {
+int CallFstat(int fd, stat_wrapper_t* sb) {
return fstat64(fd, sb);
}
#endif
@@ -52,9 +52,9 @@
// http://pubs.opengroup.org/onlinepubs/9699919799/
timespec ts_times[2];
- ts_times[0].tv_sec = times[0].tv_sec;
+ ts_times[0].tv_sec = times[0].tv_sec;
ts_times[0].tv_nsec = times[0].tv_usec * 1000;
- ts_times[1].tv_sec = times[1].tv_sec;
+ ts_times[1].tv_sec = times[1].tv_sec;
ts_times[1].tv_nsec = times[1].tv_usec * 1000;
return futimens(file, ts_times);
@@ -126,20 +126,17 @@
#error
#endif
- last_modified =
- Time::FromTimeT(last_modified_sec) +
- TimeDelta::FromMicroseconds(last_modified_nsec /
- Time::kNanosecondsPerMicrosecond);
+ last_modified = Time::FromTimeT(last_modified_sec) +
+ TimeDelta::FromMicroseconds(last_modified_nsec /
+ Time::kNanosecondsPerMicrosecond);
- last_accessed =
- Time::FromTimeT(last_accessed_sec) +
- TimeDelta::FromMicroseconds(last_accessed_nsec /
- Time::kNanosecondsPerMicrosecond);
+ last_accessed = Time::FromTimeT(last_accessed_sec) +
+ TimeDelta::FromMicroseconds(last_accessed_nsec /
+ Time::kNanosecondsPerMicrosecond);
- creation_time =
- Time::FromTimeT(creation_time_sec) +
- TimeDelta::FromMicroseconds(creation_time_nsec /
- Time::kNanosecondsPerMicrosecond);
+ creation_time = Time::FromTimeT(creation_time_sec) +
+ TimeDelta::FromMicroseconds(creation_time_nsec /
+ Time::kNanosecondsPerMicrosecond);
}
bool File::IsValid() const {
@@ -177,8 +174,8 @@
int bytes_read = 0;
int rv;
do {
- rv = HANDLE_EINTR(pread(file_.get(), data + bytes_read,
- size - bytes_read, offset + bytes_read));
+ rv = HANDLE_EINTR(pread(file_.get(), data + bytes_read, size - bytes_read,
+ offset + bytes_read));
if (rv <= 0)
break;
@@ -249,8 +246,8 @@
int bytes_written = 0;
int rv;
do {
- rv = HANDLE_EINTR(write(file_.get(), data + bytes_written,
- size - bytes_written));
+ rv = HANDLE_EINTR(
+ write(file_.get(), data + bytes_written, size - bytes_written));
if (rv <= 0)
break;
@@ -399,10 +396,8 @@
open_flags |= O_RDWR;
} else if (flags & FLAG_WRITE) {
open_flags |= O_WRONLY;
- } else if (!(flags & FLAG_READ) &&
- !(flags & FLAG_WRITE_ATTRIBUTES) &&
- !(flags & FLAG_APPEND) &&
- !(flags & FLAG_OPEN_ALWAYS)) {
+ } else if (!(flags & FLAG_READ) && !(flags & FLAG_WRITE_ATTRIBUTES) &&
+ !(flags & FLAG_APPEND) && !(flags & FLAG_OPEN_ALWAYS)) {
NOTREACHED();
}
@@ -423,7 +418,7 @@
if (descriptor < 0) {
open_flags |= O_CREAT;
if (flags & FLAG_EXCLUSIVE_READ || flags & FLAG_EXCLUSIVE_WRITE)
- open_flags |= O_EXCL; // together with O_CREAT implies O_NOFOLLOW
+ open_flags |= O_EXCL; // together with O_CREAT implies O_NOFOLLOW
descriptor = HANDLE_EINTR(open(path.value().c_str(), open_flags, mode));
if (descriptor >= 0)
diff --git a/base/files/file_util.cc b/base/files/file_util.cc
index 887139b..b30057e 100644
--- a/base/files/file_util.cc
+++ b/base/files/file_util.cc
@@ -69,8 +69,7 @@
file1.read(buffer1, BUFFER_SIZE);
file2.read(buffer2, BUFFER_SIZE);
- if ((file1.eof() != file2.eof()) ||
- (file1.gcount() != file2.gcount()) ||
+ if ((file1.eof() != file2.eof()) || (file1.gcount() != file2.gcount()) ||
(memcmp(buffer1, buffer2, static_cast<size_t>(file1.gcount())))) {
file1.close();
file2.close();
@@ -98,8 +97,7 @@
getline(file2, line2);
// Check for mismatched EOF states, or any error state.
- if ((file1.eof() != file2.eof()) ||
- file1.bad() || file2.bad()) {
+ if ((file1.eof() != file2.eof()) || file1.bad() || file2.bad()) {
return false;
}
@@ -194,7 +192,7 @@
#if !defined(OS_NACL_NONSFI)
bool IsDirectoryEmpty(const FilePath& dir_path) {
FileEnumerator files(dir_path, false,
- FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
+ FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
if (files.Next().empty())
return true;
return false;
diff --git a/base/files/file_util.h b/base/files/file_util.h
index 1401108..6176073 100644
--- a/base/files/file_util.h
+++ b/base/files/file_util.h
@@ -90,8 +90,8 @@
// Returns true on success, leaving *error unchanged.
// Returns false on failure and sets *error appropriately, if it is non-NULL.
bool ReplaceFile(const FilePath& from_path,
- const FilePath& to_path,
- File::Error* error);
+ const FilePath& to_path,
+ File::Error* error);
// Copies a single file. Use CopyDirectory() to copy directories.
// This function fails if either path contains traversal components ('..').
@@ -125,14 +125,14 @@
//
// If you only need to copy a file use CopyFile, it's faster.
bool CopyDirectory(const FilePath& from_path,
- const FilePath& to_path,
- bool recursive);
+ const FilePath& to_path,
+ bool recursive);
// Like CopyDirectory() except trying to overwrite an existing file will not
// work and will return false.
bool CopyDirectoryExcl(const FilePath& from_path,
- const FilePath& to_path,
- bool recursive);
+ const FilePath& to_path,
+ bool recursive);
// Returns true if the given path exists on the local filesystem,
// false otherwise.
@@ -146,13 +146,11 @@
// Returns true if the contents of the two files given are equal, false
// otherwise. If either file can't be read, returns false.
-bool ContentsEqual(const FilePath& filename1,
- const FilePath& filename2);
+bool ContentsEqual(const FilePath& filename1, const FilePath& filename2);
// Returns true if the contents of the two text files given are equal, false
// otherwise. This routine treats "\r\n" and "\n" as equivalent.
-bool TextContentsEqual(const FilePath& filename1,
- const FilePath& filename2);
+bool TextContentsEqual(const FilePath& filename1, const FilePath& filename2);
// Reads the file at |path| into |contents| and returns true on success and
// false on error. For security reasons, a |path| containing path traversal
@@ -173,8 +171,8 @@
// |contents| may be NULL, in which case this function is useful for its side
// effect of priming the disk cache (could be used for unit tests).
bool ReadFileToStringWithMaxSize(const FilePath& path,
- std::string* contents,
- size_t max_size);
+ std::string* contents,
+ size_t max_size);
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
@@ -186,8 +184,7 @@
// Performs the same function as CreateAndOpenTemporaryFileInDir(), but returns
// the file-descriptor directly, rather than wrapping it into a FILE. Returns
// -1 on failure.
-int CreateAndOpenFdForTemporaryFileInDir(const FilePath& dir,
- FilePath* path);
+int CreateAndOpenFdForTemporaryFileInDir(const FilePath& dir, FilePath* path);
#endif // OS_POSIX || OS_FUCHSIA
@@ -195,8 +192,7 @@
// Creates a symbolic link at |symlink| pointing to |target|. Returns
// false on failure.
-bool CreateSymbolicLink(const FilePath& target,
- const FilePath& symlink);
+bool CreateSymbolicLink(const FilePath& target, const FilePath& symlink);
// Reads the given |symlink| and returns where it points to in |target|.
// Returns false upon failure.
@@ -204,19 +200,19 @@
// Bits and masks of the file permission.
enum FilePermissionBits {
- FILE_PERMISSION_MASK = S_IRWXU | S_IRWXG | S_IRWXO,
- FILE_PERMISSION_USER_MASK = S_IRWXU,
- FILE_PERMISSION_GROUP_MASK = S_IRWXG,
- FILE_PERMISSION_OTHERS_MASK = S_IRWXO,
+ FILE_PERMISSION_MASK = S_IRWXU | S_IRWXG | S_IRWXO,
+ FILE_PERMISSION_USER_MASK = S_IRWXU,
+ FILE_PERMISSION_GROUP_MASK = S_IRWXG,
+ FILE_PERMISSION_OTHERS_MASK = S_IRWXO,
- FILE_PERMISSION_READ_BY_USER = S_IRUSR,
- FILE_PERMISSION_WRITE_BY_USER = S_IWUSR,
- FILE_PERMISSION_EXECUTE_BY_USER = S_IXUSR,
- FILE_PERMISSION_READ_BY_GROUP = S_IRGRP,
- FILE_PERMISSION_WRITE_BY_GROUP = S_IWGRP,
- FILE_PERMISSION_EXECUTE_BY_GROUP = S_IXGRP,
- FILE_PERMISSION_READ_BY_OTHERS = S_IROTH,
- FILE_PERMISSION_WRITE_BY_OTHERS = S_IWOTH,
+ FILE_PERMISSION_READ_BY_USER = S_IRUSR,
+ FILE_PERMISSION_WRITE_BY_USER = S_IWUSR,
+ FILE_PERMISSION_EXECUTE_BY_USER = S_IXUSR,
+ FILE_PERMISSION_READ_BY_GROUP = S_IRGRP,
+ FILE_PERMISSION_WRITE_BY_GROUP = S_IWGRP,
+ FILE_PERMISSION_EXECUTE_BY_GROUP = S_IXGRP,
+ FILE_PERMISSION_READ_BY_OTHERS = S_IROTH,
+ FILE_PERMISSION_WRITE_BY_OTHERS = S_IWOTH,
FILE_PERMISSION_EXECUTE_BY_OTHERS = S_IXOTH,
};
@@ -231,7 +227,7 @@
// Returns true iff |executable| can be found in any directory specified by the
// environment variable in |env|.
bool ExecutableExistsInPath(Environment* env,
- const FilePath::StringType& executable);
+ const FilePath::StringType& executable);
#endif // OS_POSIX
@@ -260,8 +256,7 @@
bool CreateTemporaryFile(FilePath* path);
// Same as CreateTemporaryFile but the file is created in |dir|.
-bool CreateTemporaryFileInDir(const FilePath& dir,
- FilePath* temp_file);
+bool CreateTemporaryFileInDir(const FilePath& dir, FilePath* temp_file);
// Create and open a temporary file. File is opened for read/write.
// The full path is placed in |path|.
@@ -269,30 +264,28 @@
FILE* CreateAndOpenTemporaryFile(FilePath* path);
// Similar to CreateAndOpenTemporaryFile, but the file is created in |dir|.
-FILE* CreateAndOpenTemporaryFileInDir(const FilePath& dir,
- FilePath* path);
+FILE* CreateAndOpenTemporaryFileInDir(const FilePath& dir, FilePath* path);
// Create a new directory. If prefix is provided, the new directory name is in
// the format of prefixyyyy.
// NOTE: prefix is ignored in the POSIX implementation.
// If success, return true and output the full path of the directory created.
bool CreateNewTempDirectory(const FilePath::StringType& prefix,
- FilePath* new_temp_path);
+ FilePath* new_temp_path);
// Create a directory within another directory.
// Extra characters will be appended to |prefix| to ensure that the
// new directory does not have the same name as an existing directory.
bool CreateTemporaryDirInDir(const FilePath& base_dir,
- const FilePath::StringType& prefix,
- FilePath* new_dir);
+ const FilePath::StringType& prefix,
+ FilePath* new_dir);
// Creates a directory, as well as creating any parent directories, if they
// don't exist. Returns 'true' on successful creation, or if the directory
// already exists. The directory is only readable by the current user.
// Returns true on success, leaving *error unchanged.
// Returns false on failure and sets *error appropriately, if it is non-NULL.
-bool CreateDirectoryAndGetError(const FilePath& full_path,
- File::Error* error);
+bool CreateDirectoryAndGetError(const FilePath& full_path, File::Error* error);
// Backward-compatible convenience method for the above.
bool CreateDirectory(const FilePath& full_path);
@@ -314,14 +307,13 @@
// return in |drive_letter_path| the equivalent path that starts with
// a drive letter ("C:\..."). Return false if no such path exists.
bool DevicePathToDriveLetterPath(const FilePath& device_path,
- FilePath* drive_letter_path);
+ FilePath* drive_letter_path);
// Given an existing file in |path|, set |real_path| to the path
// in native NT format, of the form "\Device\HarddiskVolumeXX\..".
// Returns false if the path can not be found. Empty files cannot
// be resolved with this function.
-bool NormalizeToNativeFilePath(const FilePath& path,
- FilePath* nt_path);
+bool NormalizeToNativeFilePath(const FilePath& path, FilePath* nt_path);
#endif
// This function will return if the given file is a symlink or not.
@@ -332,8 +324,8 @@
// Sets the time of the last access and the time of the last modification.
bool TouchFile(const FilePath& path,
- const Time& last_accessed,
- const Time& last_modified);
+ const Time& last_accessed,
+ const Time& last_modified);
// Wrapper for fopen-like calls. Returns non-NULL FILE* on success. The
// underlying file descriptor (POSIX) or handle (Windows) is unconditionally
@@ -357,8 +349,7 @@
// Writes the given buffer into the file, overwriting any data that was
// previously there. Returns the number of bytes written, or -1 on error.
-int WriteFile(const FilePath& filename, const char* data,
- int size);
+int WriteFile(const FilePath& filename, const char* data, int size);
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
// Appends |data| to |fd|. Does not close |fd| when done. Returns true iff
@@ -368,9 +359,7 @@
// Appends |data| to |filename|. Returns true iff |size| bytes of |data| were
// written to |filename|.
-bool AppendToFile(const FilePath& filename,
- const char* data,
- int size);
+bool AppendToFile(const FilePath& filename, const char* data, int size);
// Gets the current working directory for the process.
bool GetCurrentDirectory(FilePath* path);
@@ -383,7 +372,7 @@
// a number, -1 is returned. If |suffix| is not empty, also checks the
// existence of it with the given suffix.
int GetUniquePathNumber(const FilePath& path,
- const FilePath::StringType& suffix);
+ const FilePath::StringType& suffix);
// Sets the given |fd| to non-blocking mode.
// Returns true if it was able to set it in the non-blocking mode, otherwise
@@ -414,9 +403,9 @@
// This is useful for checking that a config file is administrator-controlled.
// |base| must contain |path|.
bool VerifyPathControlledByUser(const base::FilePath& base,
- const base::FilePath& path,
- uid_t owner_uid,
- const std::set<gid_t>& group_gids);
+ const base::FilePath& path,
+ uid_t owner_uid,
+ const std::set<gid_t>& group_gids);
#endif // defined(OS_POSIX) || defined(OS_FUCHSIA)
#if defined(OS_MACOSX) && !defined(OS_IOS)
@@ -437,15 +426,15 @@
#if defined(OS_LINUX) || defined(OS_AIX)
// Broad categories of file systems as returned by statfs() on Linux.
enum FileSystemType {
- FILE_SYSTEM_UNKNOWN, // statfs failed.
- FILE_SYSTEM_0, // statfs.f_type == 0 means unknown, may indicate AFS.
- FILE_SYSTEM_ORDINARY, // on-disk filesystem like ext2
+ FILE_SYSTEM_UNKNOWN, // statfs failed.
+ FILE_SYSTEM_0, // statfs.f_type == 0 means unknown, may indicate AFS.
+ FILE_SYSTEM_ORDINARY, // on-disk filesystem like ext2
FILE_SYSTEM_NFS,
FILE_SYSTEM_SMB,
FILE_SYSTEM_CODA,
- FILE_SYSTEM_MEMORY, // in-memory file system
- FILE_SYSTEM_CGROUP, // cgroup control.
- FILE_SYSTEM_OTHER, // any other value.
+ FILE_SYSTEM_MEMORY, // in-memory file system
+ FILE_SYSTEM_CGROUP, // cgroup control.
+ FILE_SYSTEM_OTHER, // any other value.
FILE_SYSTEM_TYPE_COUNT
};
@@ -469,16 +458,14 @@
// Same as Move but allows paths with traversal components.
// Use only with extreme care.
-bool MoveUnsafe(const FilePath& from_path,
- const FilePath& to_path);
+bool MoveUnsafe(const FilePath& from_path, const FilePath& to_path);
#if defined(OS_WIN)
// Copy from_path to to_path recursively and then delete from_path recursively.
// Returns true if all operations succeed.
// This function simulates Move(), but unlike Move() it works across volumes.
// This function is not transactional.
-bool CopyAndDeleteDirectory(const FilePath& from_path,
- const FilePath& to_path);
+bool CopyAndDeleteDirectory(const FilePath& from_path, const FilePath& to_path);
#endif // defined(OS_WIN)
} // namespace internal
diff --git a/base/files/file_util_mac.mm b/base/files/file_util_mac.mm
index 0b2e2a0..35fd27a 100644
--- a/base/files/file_util_mac.mm
+++ b/base/files/file_util_mac.mm
@@ -19,8 +19,8 @@
bool CopyFile(const FilePath& from_path, const FilePath& to_path) {
if (from_path.ReferencesParent() || to_path.ReferencesParent())
return false;
- return (copyfile(from_path.value().c_str(),
- to_path.value().c_str(), NULL, COPYFILE_DATA) == 0);
+ return (copyfile(from_path.value().c_str(), to_path.value().c_str(), NULL,
+ COPYFILE_DATA) == 0);
}
bool GetTempDir(base::FilePath* path) {
diff --git a/base/files/file_util_posix.cc b/base/files/file_util_posix.cc
index 6fb43bd..83cace9 100644
--- a/base/files/file_util_posix.cc
+++ b/base/files/file_util_posix.cc
@@ -76,8 +76,7 @@
const std::set<gid_t>& group_gids) {
stat_wrapper_t stat_info;
if (CallLstat(path.value().c_str(), &stat_info) != 0) {
- DPLOG(ERROR) << "Failed to get information on path "
- << path.value();
+ DPLOG(ERROR) << "Failed to get information on path " << path.value();
return false;
}
@@ -297,11 +296,11 @@
open_flags |= O_EXCL;
else
open_flags |= O_TRUNC | O_NONBLOCK;
- // Each platform has different default file opening modes for CopyFile which
- // we want to replicate here. On OS X, we use copyfile(3) which takes the
- // source file's permissions into account. On the other platforms, we just
- // use the base::File constructor. On Chrome OS, base::File uses a different
- // set of permissions than it does on other POSIX platforms.
+// Each platform has different default file opening modes for CopyFile which
+// we want to replicate here. On OS X, we use copyfile(3) which takes the
+// source file's permissions into account. On the other platforms, we just
+// use the base::File constructor. On Chrome OS, base::File uses a different
+// set of permissions than it does on other POSIX platforms.
#if defined(OS_MACOSX)
int mode = 0600 | (stat_at_use.st_mode & 0177);
#else
@@ -367,8 +366,8 @@
stack<std::string> directories;
directories.push(path.value());
FileEnumerator traversal(path, true,
- FileEnumerator::FILES | FileEnumerator::DIRECTORIES |
- FileEnumerator::SHOW_SYM_LINKS);
+ FileEnumerator::FILES | FileEnumerator::DIRECTORIES |
+ FileEnumerator::SHOW_SYM_LINKS);
for (FilePath current = traversal.Next(); !current.empty();
current = traversal.Next()) {
if (traversal.GetInfo().IsDirectory())
@@ -503,8 +502,8 @@
const FilePath& symlink_path) {
DCHECK(!symlink_path.empty());
DCHECK(!target_path.empty());
- return ::symlink(target_path.value().c_str(),
- symlink_path.value().c_str()) != -1;
+ return ::symlink(target_path.value().c_str(), symlink_path.value().c_str()) !=
+ -1;
}
bool ReadSymbolicLink(const FilePath& symlink_path, FilePath* target_path) {
@@ -535,8 +534,7 @@
return true;
}
-bool SetPosixFilePermissions(const FilePath& path,
- int mode) {
+bool SetPosixFilePermissions(const FilePath& path, int mode) {
DCHECK_EQ(mode & ~FILE_PERMISSION_MASK, 0);
// Calls stat() so that we can preserve the higher bits like S_ISGID.
@@ -668,15 +666,14 @@
return CreateTemporaryDirInDirImpl(tmpdir, TempFileName(), new_temp_path);
}
-bool CreateDirectoryAndGetError(const FilePath& full_path,
- File::Error* error) {
+bool CreateDirectoryAndGetError(const FilePath& full_path, File::Error* error) {
std::vector<FilePath> subpaths;
// Collect a list of all parent directories.
FilePath last_path = full_path;
subpaths.push_back(full_path);
- for (FilePath path = full_path.DirName();
- path.value() != last_path.value(); path = path.DirName()) {
+ for (FilePath path = full_path.DirName(); path.value() != last_path.value();
+ path = path.DirName()) {
subpaths.push_back(path);
last_path = path;
}
@@ -800,9 +797,8 @@
ssize_t bytes_written_total = 0;
for (ssize_t bytes_written_partial = 0; bytes_written_total < size;
bytes_written_total += bytes_written_partial) {
- bytes_written_partial =
- HANDLE_EINTR(write(fd, data + bytes_written_total,
- size - bytes_written_total));
+ bytes_written_partial = HANDLE_EINTR(
+ write(fd, data + bytes_written_total, size - bytes_written_total));
if (bytes_written_partial < 0)
return false;
}
@@ -850,9 +846,9 @@
uid_t owner_uid,
const std::set<gid_t>& group_gids) {
if (base != path && !base.IsParent(path)) {
- DLOG(ERROR) << "|base| must be a subdirectory of |path|. base = \""
- << base.value() << "\", path = \"" << path.value() << "\"";
- return false;
+ DLOG(ERROR) << "|base| must be a subdirectory of |path|. base = \""
+ << base.value() << "\", path = \"" << path.value() << "\"";
+ return false;
}
std::vector<FilePath::StringType> base_components;
@@ -877,8 +873,8 @@
for (; ip != path_components.end(); ++ip) {
current_path = current_path.Append(*ip);
- if (!VerifySpecificPathControlledByUser(
- current_path, owner_uid, group_gids))
+ if (!VerifySpecificPathControlledByUser(current_path, owner_uid,
+ group_gids))
return false;
}
return true;
@@ -890,14 +886,11 @@
const FilePath kFileSystemRoot("/");
// The name of the administrator group on mac os.
- const char* const kAdminGroupNames[] = {
- "admin",
- "wheel"
- };
+ const char* const kAdminGroupNames[] = {"admin", "wheel"};
std::set<gid_t> allowed_group_ids;
for (int i = 0, ie = arraysize(kAdminGroupNames); i < ie; ++i) {
- struct group *group_record = getgrnam(kAdminGroupNames[i]);
+ struct group* group_record = getgrnam(kAdminGroupNames[i]);
if (!group_record) {
DPLOG(ERROR) << "Could not get the group ID of group \""
<< kAdminGroupNames[i] << "\".";
@@ -907,8 +900,8 @@
allowed_group_ids.insert(group_record->gr_gid);
}
- return VerifyPathControlledByUser(
- kFileSystemRoot, path, kRootUid, allowed_group_ids);
+ return VerifyPathControlledByUser(kFileSystemRoot, path, kRootUid,
+ allowed_group_ids);
}
#endif // defined(OS_MACOSX) && !defined(OS_IOS)
diff --git a/base/files/file_util_win.cc b/base/files/file_util_win.cc
index d59b7e4..48190ad 100644
--- a/base/files/file_util_win.cc
+++ b/base/files/file_util_win.cc
@@ -5,6 +5,7 @@
#include "base/files/file_util.h"
#include <windows.h>
+
#include <io.h>
#include <psapi.h>
#include <shellapi.h>
@@ -326,8 +327,8 @@
return false;
return MoveFileEx(path.value().c_str(), NULL,
- MOVEFILE_DELAY_UNTIL_REBOOT |
- MOVEFILE_REPLACE_EXISTING) != FALSE;
+ MOVEFILE_DELAY_UNTIL_REBOOT | MOVEFILE_REPLACE_EXISTING) !=
+ FALSE;
}
bool ReplaceFile(const FilePath& from_path,
@@ -376,8 +377,8 @@
bool PathIsWritable(const FilePath& path) {
HANDLE dir =
- CreateFile(path.value().c_str(), FILE_ADD_FILE, kFileShareAll,
- NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+ CreateFile(path.value().c_str(), FILE_ADD_FILE, kFileShareAll, NULL,
+ OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (dir == INVALID_HANDLE_VALUE)
return false;
@@ -528,8 +529,7 @@
return CreateTemporaryDirInDir(system_temp_dir, prefix, new_temp_path);
}
-bool CreateDirectoryAndGetError(const FilePath& full_path,
- File::Error* error) {
+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);
@@ -622,14 +622,16 @@
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)));
+ *out_drive_letter_path =
+ FilePath(drive + nt_device_path.value().substr(
+ wcslen(device_path_as_string)));
return true;
}
}
// Move to the next drive letter string, which starts one
// increment after the '\0' that terminates the current string.
- while (*drive_map_ptr++) {}
+ while (*drive_map_ptr++) {
+ }
}
// No drive matched. The path does not start with a device junction
@@ -644,14 +646,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(path.value().c_str(), GENERIC_READ,
+ kFileShareAll, NULL, OPEN_EXISTING,
+ FILE_ATTRIBUTE_NORMAL, NULL));
if (!file_handle.IsValid())
return false;
@@ -659,18 +656,15 @@
// we only map the first byte, and need direct access to the handle. You can
// not map an empty file, this call fails in that case.
win::ScopedHandle file_map_handle(
- ::CreateFileMapping(file_handle.Get(),
- NULL,
- PAGE_READONLY,
- 0,
+ ::CreateFileMapping(file_handle.Get(), NULL, PAGE_READONLY, 0,
1, // Just one byte. No need to look at the data.
NULL));
if (!file_map_handle.IsValid())
return false;
// Use a view of the file to get the path to the file.
- void* file_view = MapViewOfFile(file_map_handle.Get(),
- FILE_MAP_READ, 0, 0, 1);
+ void* file_view =
+ MapViewOfFile(file_map_handle.Get(), FILE_MAP_READ, 0, 0, 1);
if (!file_view)
return false;
@@ -700,8 +694,8 @@
bool GetFileInfo(const FilePath& file_path, File::Info* results) {
WIN32_FILE_ATTRIBUTE_DATA attr;
- if (!GetFileAttributesEx(file_path.value().c_str(),
- GetFileExInfoStandard, &attr)) {
+ if (!GetFileAttributesEx(file_path.value().c_str(), GetFileExInfoStandard,
+ &attr)) {
return false;
}
@@ -745,12 +739,9 @@
}
int ReadFile(const FilePath& filename, char* data, int max_size) {
- win::ScopedHandle file(CreateFile(filename.value().c_str(),
- GENERIC_READ,
- FILE_SHARE_READ | FILE_SHARE_WRITE,
- NULL,
- OPEN_EXISTING,
- FILE_FLAG_SEQUENTIAL_SCAN,
+ win::ScopedHandle file(CreateFile(filename.value().c_str(), GENERIC_READ,
+ FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+ OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN,
NULL));
if (!file.IsValid())
return -1;
@@ -790,13 +781,8 @@
}
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(filename.value().c_str(), FILE_APPEND_DATA,
+ 0, NULL, OPEN_EXISTING, 0, NULL));
if (!file.IsValid()) {
return false;
}
@@ -830,8 +816,7 @@
int GetMaximumPathComponentLength(const FilePath& path) {
wchar_t volume_path[MAX_PATH];
if (!GetVolumePathNameW(path.NormalizePathSeparators().value().c_str(),
- volume_path,
- arraysize(volume_path))) {
+ volume_path, arraysize(volume_path))) {
return -1;
}
diff --git a/base/files/file_win.cc b/base/files/file_win.cc
index e922ad8..401ac33 100644
--- a/base/files/file_win.cc
+++ b/base/files/file_win.cc
@@ -226,7 +226,7 @@
GetPlatformFile(),
GetCurrentProcess(), // hTargetProcessHandle
&other_handle,
- 0, // dwDesiredAccess ignored due to SAME_ACCESS
+ 0, // dwDesiredAccess ignored due to SAME_ACCESS
FALSE, // !bInheritHandle
DUPLICATE_SAME_ACCESS)) {
return File(GetLastFileError());
@@ -355,8 +355,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(path.value().c_str(), access, sharing, NULL, disposition,
+ create_flags, NULL));
if (file_.IsValid()) {
error_details_ = FILE_OK;
diff --git a/base/files/scoped_file.h b/base/files/scoped_file.h
index c1a2988..f262f18 100644
--- a/base/files/scoped_file.h
+++ b/base/files/scoped_file.h
@@ -19,9 +19,7 @@
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
struct ScopedFDCloseTraits {
- static int InvalidValue() {
- return -1;
- }
+ static int InvalidValue() { return -1; }
static void Free(int fd);
};
#endif
diff --git a/base/gtest_prod_util.h b/base/gtest_prod_util.h
index 6df62e2..664dded 100644
--- a/base/gtest_prod_util.h
+++ b/base/gtest_prod_util.h
@@ -6,11 +6,11 @@
#define BASE_GTEST_PROD_UTIL_H_
// TODO: Remove me.
-#define FRIEND_TEST_ALL_PREFIXES(test_case_name, test_name) \
+#define FRIEND_TEST_ALL_PREFIXES(test_case_name, test_name) \
friend class test_case_name##test_name
// TODO: Remove me.
-#define FORWARD_DECLARE_TEST(test_case_name, test_name) \
+#define FORWARD_DECLARE_TEST(test_case_name, test_name) \
class test_case_name##test_name
#endif // BASE_GTEST_PROD_UTIL_H_
diff --git a/base/json/json_file_value_serializer.cc b/base/json/json_file_value_serializer.cc
index b0974c0..ac3ba7b 100644
--- a/base/json/json_file_value_serializer.cc
+++ b/base/json/json_file_value_serializer.cc
@@ -18,8 +18,7 @@
JSONFileValueSerializer::JSONFileValueSerializer(
const base::FilePath& json_file_path)
- : json_file_path_(json_file_path) {
-}
+ : json_file_path_(json_file_path) {}
JSONFileValueSerializer::~JSONFileValueSerializer() = default;
@@ -37,9 +36,9 @@
std::string json_string;
JSONStringValueSerializer serializer(&json_string);
serializer.set_pretty_print(true);
- bool result = omit_binary_values ?
- serializer.SerializeAndOmitBinaryValues(root) :
- serializer.Serialize(root);
+ bool result = omit_binary_values
+ ? serializer.SerializeAndOmitBinaryValues(root)
+ : serializer.Serialize(root);
if (!result)
return false;
diff --git a/base/json/json_file_value_serializer.h b/base/json/json_file_value_serializer.h
index db243b7..b260543 100644
--- a/base/json/json_file_value_serializer.h
+++ b/base/json/json_file_value_serializer.h
@@ -99,4 +99,3 @@
};
#endif // BASE_JSON_JSON_FILE_VALUE_SERIALIZER_H_
-
diff --git a/base/json/json_parser.cc b/base/json/json_parser.cc
index e6483ee..713f692 100644
--- a/base/json/json_parser.cc
+++ b/base/json/json_parser.cc
@@ -35,9 +35,7 @@
++(*depth_);
DCHECK_LE(*depth_, max_depth_);
}
- ~StackMarker() {
- --(*depth_);
- }
+ ~StackMarker() { --(*depth_); }
bool IsTooDeep() const { return *depth_ >= max_depth_; }
@@ -112,7 +110,7 @@
std::string JSONParser::GetErrorMessage() const {
return FormatErrorMessage(error_line_, error_column_,
- JSONReader::ErrorCodeToString(error_code_));
+ JSONReader::ErrorCodeToString(error_code_));
}
int JSONParser::error_line() const {
@@ -454,8 +452,7 @@
while (PeekChar()) {
uint32_t next_char = 0;
if (!ReadUnicodeCharacter(input_.data(),
- static_cast<int32_t>(input_.length()),
- &index_,
+ static_cast<int32_t>(input_.length()), &index_,
&next_char) ||
!IsValidCharacter(next_char)) {
if ((options_ & JSON_REPLACE_INVALID_CHARACTERS) == 0) {
@@ -736,11 +733,12 @@
}
// static
-std::string JSONParser::FormatErrorMessage(int line, int column,
+std::string JSONParser::FormatErrorMessage(int line,
+ int column,
const std::string& description) {
if (line || column) {
- return StringPrintf("Line: %i, column: %i, %s",
- line, column, description.c_str());
+ return StringPrintf("Line: %i, column: %i, %s", line, column,
+ description.c_str());
}
return description;
}
diff --git a/base/json/json_parser.h b/base/json/json_parser.h
index b14a8d7..1289560 100644
--- a/base/json/json_parser.h
+++ b/base/json/json_parser.h
@@ -67,10 +67,10 @@
private:
enum Token {
- T_OBJECT_BEGIN, // {
- T_OBJECT_END, // }
- T_ARRAY_BEGIN, // [
- T_ARRAY_END, // ]
+ T_OBJECT_BEGIN, // {
+ T_OBJECT_END, // }
+ T_ARRAY_BEGIN, // [
+ T_ARRAY_END, // ]
T_STRING,
T_NUMBER,
T_BOOL_TRUE, // true
@@ -207,7 +207,8 @@
// Given the line and column number of an error, formats one of the error
// message contants from json_reader.h for human display.
- static std::string FormatErrorMessage(int line, int column,
+ static std::string FormatErrorMessage(int line,
+ int column,
const std::string& description);
// base::JSONParserOptions that control parsing.
diff --git a/base/json/json_reader.cc b/base/json/json_reader.cc
index bf2a18a..3d5475e 100644
--- a/base/json/json_reader.cc
+++ b/base/json/json_reader.cc
@@ -22,24 +22,18 @@
static_assert(JSONReader::JSON_PARSE_ERROR_COUNT < 1000,
"JSONReader error out of bounds");
-const char JSONReader::kInvalidEscape[] =
- "Invalid escape sequence.";
-const char JSONReader::kSyntaxError[] =
- "Syntax error.";
-const char JSONReader::kUnexpectedToken[] =
- "Unexpected token.";
-const char JSONReader::kTrailingComma[] =
- "Trailing comma not allowed.";
-const char JSONReader::kTooMuchNesting[] =
- "Too much nesting.";
+const char JSONReader::kInvalidEscape[] = "Invalid escape sequence.";
+const char JSONReader::kSyntaxError[] = "Syntax error.";
+const char JSONReader::kUnexpectedToken[] = "Unexpected token.";
+const char JSONReader::kTrailingComma[] = "Trailing comma not allowed.";
+const char JSONReader::kTooMuchNesting[] = "Too much nesting.";
const char JSONReader::kUnexpectedDataAfterRoot[] =
"Unexpected data after root element.";
const char JSONReader::kUnsupportedEncoding[] =
"Unsupported encoding. JSON must be UTF-8.";
const char JSONReader::kUnquotedDictionaryKey[] =
"Dictionary keys must be quoted.";
-const char JSONReader::kInputTooLarge[] =
- "Input string is too large (>2GB).";
+const char JSONReader::kInputTooLarge[] = "Input string is too large (>2GB).";
JSONReader::JSONReader(int options, int max_depth)
: parser_(new internal::JSONParser(options, max_depth)) {}
@@ -55,7 +49,6 @@
return root ? std::make_unique<Value>(std::move(*root)) : nullptr;
}
-
// static
std::unique_ptr<Value> JSONReader::ReadAndReturnError(
StringPiece json,
diff --git a/base/json/json_string_value_serializer.cc b/base/json/json_string_value_serializer.cc
index f9c45a4..0c979b7 100644
--- a/base/json/json_string_value_serializer.cc
+++ b/base/json/json_string_value_serializer.cc
@@ -11,9 +11,7 @@
using base::Value;
JSONStringValueSerializer::JSONStringValueSerializer(std::string* json_string)
- : json_string_(json_string),
- pretty_print_(false) {
-}
+ : json_string_(json_string), pretty_print_(false) {}
JSONStringValueSerializer::~JSONStringValueSerializer() = default;
diff --git a/base/json/json_value_converter.cc b/base/json/json_value_converter.cc
index 6f772f3..55506e6 100644
--- a/base/json/json_value_converter.cc
+++ b/base/json/json_value_converter.cc
@@ -7,31 +7,30 @@
namespace base {
namespace internal {
-bool BasicValueConverter<int>::Convert(
- const base::Value& value, int* field) const {
+bool BasicValueConverter<int>::Convert(const base::Value& value,
+ int* field) const {
return value.GetAsInteger(field);
}
-bool BasicValueConverter<std::string>::Convert(
- const base::Value& value, std::string* field) const {
+bool BasicValueConverter<std::string>::Convert(const base::Value& value,
+ std::string* field) const {
return value.GetAsString(field);
}
-bool BasicValueConverter<string16>::Convert(
- const base::Value& value, string16* field) const {
+bool BasicValueConverter<string16>::Convert(const base::Value& value,
+ string16* field) const {
return value.GetAsString(field);
}
-bool BasicValueConverter<double>::Convert(
- const base::Value& value, double* field) const {
+bool BasicValueConverter<double>::Convert(const base::Value& value,
+ double* field) const {
return value.GetAsDouble(field);
}
-bool BasicValueConverter<bool>::Convert(
- const base::Value& value, bool* field) const {
+bool BasicValueConverter<bool>::Convert(const base::Value& value,
+ bool* field) const {
return value.GetAsBoolean(field);
}
} // namespace internal
} // namespace base
-
diff --git a/base/json/json_value_converter.h b/base/json/json_value_converter.h
index 115e47a..d91bead 100644
--- a/base/json/json_value_converter.h
+++ b/base/json/json_value_converter.h
@@ -91,13 +91,13 @@
namespace internal {
-template<typename StructType>
+template <typename StructType>
class FieldConverterBase {
public:
explicit FieldConverterBase(const std::string& path) : field_path_(path) {}
virtual ~FieldConverterBase() = default;
- virtual bool ConvertField(const base::Value& value, StructType* obj)
- const = 0;
+ virtual bool ConvertField(const base::Value& value,
+ StructType* obj) const = 0;
const std::string& field_path() const { return field_path_; }
private:
@@ -116,19 +116,18 @@
class FieldConverter : public FieldConverterBase<StructType> {
public:
explicit FieldConverter(const std::string& path,
- FieldType StructType::* field,
+ FieldType StructType::*field,
ValueConverter<FieldType>* converter)
: FieldConverterBase<StructType>(path),
field_pointer_(field),
- value_converter_(converter) {
- }
+ value_converter_(converter) {}
bool ConvertField(const base::Value& value, StructType* dst) const override {
return value_converter_->Convert(value, &(dst->*field_pointer_));
}
private:
- FieldType StructType::* field_pointer_;
+ FieldType StructType::*field_pointer_;
std::unique_ptr<ValueConverter<FieldType>> value_converter_;
DISALLOW_COPY_AND_ASSIGN(FieldConverter);
};
@@ -148,8 +147,7 @@
};
template <>
-class BasicValueConverter<std::string>
- : public ValueConverter<std::string> {
+class BasicValueConverter<std::string> : public ValueConverter<std::string> {
public:
BasicValueConverter() = default;
@@ -160,8 +158,7 @@
};
template <>
-class BasicValueConverter<string16>
- : public ValueConverter<string16> {
+class BasicValueConverter<string16> : public ValueConverter<string16> {
public:
BasicValueConverter() = default;
@@ -196,7 +193,7 @@
template <typename FieldType>
class ValueFieldConverter : public ValueConverter<FieldType> {
public:
- typedef bool(*ConvertFunc)(const base::Value* value, FieldType* field);
+ typedef bool (*ConvertFunc)(const base::Value* value, FieldType* field);
explicit ValueFieldConverter(ConvertFunc convert_func)
: convert_func_(convert_func) {}
@@ -222,7 +219,7 @@
bool Convert(const base::Value& value, FieldType* field) const override {
std::string string_value;
return value.GetAsString(&string_value) &&
- convert_func_(string_value, field);
+ convert_func_(string_value, field);
}
private:
@@ -317,7 +314,7 @@
class RepeatedCustomValueConverter
: public ValueConverter<std::vector<std::unique_ptr<NestedType>>> {
public:
- typedef bool(*ConvertFunc)(const base::Value* value, NestedType* field);
+ typedef bool (*ConvertFunc)(const base::Value* value, NestedType* field);
explicit RepeatedCustomValueConverter(ConvertFunc convert_func)
: convert_func_(convert_func) {}
@@ -349,54 +346,50 @@
DISALLOW_COPY_AND_ASSIGN(RepeatedCustomValueConverter);
};
-
} // namespace internal
template <class StructType>
class JSONValueConverter {
public:
- JSONValueConverter() {
- StructType::RegisterJSONConverter(this);
- }
+ JSONValueConverter() { StructType::RegisterJSONConverter(this); }
- void RegisterIntField(const std::string& field_name,
- int StructType::* field) {
+ void RegisterIntField(const std::string& field_name, int StructType::*field) {
fields_.push_back(
std::make_unique<internal::FieldConverter<StructType, int>>(
field_name, field, new internal::BasicValueConverter<int>));
}
void RegisterStringField(const std::string& field_name,
- std::string StructType::* field) {
+ std::string StructType::*field) {
fields_.push_back(
std::make_unique<internal::FieldConverter<StructType, std::string>>(
field_name, field, new internal::BasicValueConverter<std::string>));
}
void RegisterStringField(const std::string& field_name,
- string16 StructType::* field) {
+ string16 StructType::*field) {
fields_.push_back(
std::make_unique<internal::FieldConverter<StructType, string16>>(
field_name, field, new internal::BasicValueConverter<string16>));
}
void RegisterBoolField(const std::string& field_name,
- bool StructType::* field) {
+ bool StructType::*field) {
fields_.push_back(
std::make_unique<internal::FieldConverter<StructType, bool>>(
field_name, field, new internal::BasicValueConverter<bool>));
}
void RegisterDoubleField(const std::string& field_name,
- double StructType::* field) {
+ double StructType::*field) {
fields_.push_back(
std::make_unique<internal::FieldConverter<StructType, double>>(
field_name, field, new internal::BasicValueConverter<double>));
}
template <class NestedType>
- void RegisterNestedField(
- const std::string& field_name, NestedType StructType::* field) {
+ void RegisterNestedField(const std::string& field_name,
+ NestedType StructType::*field) {
fields_.push_back(
std::make_unique<internal::FieldConverter<StructType, NestedType>>(
field_name, field, new internal::NestedValueConverter<NestedType>));
@@ -413,10 +406,10 @@
}
template <typename FieldType>
- void RegisterCustomValueField(
- const std::string& field_name,
- FieldType StructType::* field,
- bool (*convert_func)(const base::Value*, FieldType*)) {
+ void RegisterCustomValueField(const std::string& field_name,
+ FieldType StructType::*field,
+ bool (*convert_func)(const base::Value*,
+ FieldType*)) {
fields_.push_back(
std::make_unique<internal::FieldConverter<StructType, FieldType>>(
field_name, field,
diff --git a/base/json/string_escape.h b/base/json/string_escape.h
index 2f74836..d318b6a 100644
--- a/base/json/string_escape.h
+++ b/base/json/string_escape.h
@@ -25,16 +25,12 @@
//
// If |put_in_quotes| is true, then a leading and trailing double-quote mark
// will be appended to |dest| as well.
-bool EscapeJSONString(StringPiece str,
- bool put_in_quotes,
- std::string* dest);
+bool EscapeJSONString(StringPiece str, bool put_in_quotes, std::string* dest);
// Performs a similar function to the UTF-8 StringPiece version above,
// converting UTF-16 code units to UTF-8 code units and escaping non-printing
// control characters. On return, |dest| will contain a valid UTF-8 JSON string.
-bool EscapeJSONString(StringPiece16 str,
- bool put_in_quotes,
- std::string* dest);
+bool EscapeJSONString(StringPiece16 str, bool put_in_quotes, std::string* dest);
// Helper functions that wrap the above two functions but return the value
// instead of appending. |put_in_quotes| is always true.
@@ -52,8 +48,7 @@
//
// The output of this function takes the *appearance* of JSON but is not in
// fact valid according to RFC 4627.
-std::string EscapeBytesAsInvalidJSONString(StringPiece str,
- bool put_in_quotes);
+std::string EscapeBytesAsInvalidJSONString(StringPiece str, bool put_in_quotes);
} // namespace base
diff --git a/base/logging.cc b/base/logging.cc
index 915f2e0..f6de944 100644
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -42,9 +42,9 @@
#endif
#include <CoreFoundation/CoreFoundation.h>
+#include <mach-o/dyld.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
-#include <mach-o/dyld.h>
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
#include <time.h>
@@ -198,13 +198,9 @@
// LoggingLocks can not be nested.
class LoggingLock {
public:
- LoggingLock() {
- LockLogging();
- }
+ LoggingLock() { LockLogging(); }
- ~LoggingLock() {
- UnlockLogging();
- }
+ ~LoggingLock() { UnlockLogging(); }
static void Init(LogLockingState lock_log, const PathChar* new_log_file) {
if (initialized)
@@ -290,8 +286,8 @@
// try the current directory
wchar_t system_buffer[MAX_PATH];
system_buffer[0] = 0;
- DWORD len = ::GetCurrentDirectory(arraysize(system_buffer),
- system_buffer);
+ DWORD len =
+ ::GetCurrentDirectory(arraysize(system_buffer), system_buffer);
if (len == 0 || len > arraysize(system_buffer))
return false;
@@ -403,8 +399,10 @@
severity >= kAlwaysPrintErrorLevel;
}
-void SetLogItems(bool enable_process_id, bool enable_thread_id,
- bool enable_timestamp, bool enable_tickcount) {
+void SetLogItems(bool enable_process_id,
+ bool enable_thread_id,
+ bool enable_timestamp,
+ bool enable_tickcount) {
g_log_process_id = enable_process_id;
g_log_thread_id = enable_thread_id;
g_log_timestamp = enable_timestamp;
@@ -424,16 +422,25 @@
}
// Explicit instantiations for commonly used comparisons.
-template std::string* MakeCheckOpString<int, int>(
- const int&, const int&, const char* names);
+template std::string* MakeCheckOpString<int, int>(const int&,
+ const int&,
+ const char* names);
template std::string* MakeCheckOpString<unsigned long, unsigned long>(
- const unsigned long&, const unsigned long&, const char* names);
+ const unsigned long&,
+ const unsigned long&,
+ const char* names);
template std::string* MakeCheckOpString<unsigned long, unsigned int>(
- const unsigned long&, const unsigned int&, const char* names);
+ const unsigned long&,
+ const unsigned int&,
+ const char* names);
template std::string* MakeCheckOpString<unsigned int, unsigned long>(
- const unsigned int&, const unsigned long&, const char* names);
+ const unsigned int&,
+ const unsigned long&,
+ const char* names);
template std::string* MakeCheckOpString<std::string, std::string>(
- const std::string&, const std::string&, const char* name);
+ const std::string&,
+ const std::string&,
+ const char* name);
void MakeCheckOpValueString(std::ostream* os, std::nullptr_t p) {
(*os) << "nullptr";
@@ -462,8 +469,7 @@
#endif // !defined(NDEBUG)
#if defined(OS_WIN)
-LogMessage::SaveLastError::SaveLastError() : last_error_(::GetLastError()) {
-}
+LogMessage::SaveLastError::SaveLastError() : last_error_(::GetLastError()) {}
LogMessage::SaveLastError::~SaveLastError() {
::SetLastError(last_error_);
@@ -488,7 +494,9 @@
delete result;
}
-LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
+LogMessage::LogMessage(const char* file,
+ int line,
+ LogSeverity severity,
std::string* result)
: severity_(severity), file_(file), line_(line) {
Init(file, line);
@@ -507,9 +515,8 @@
std::string str_newline(stream_.str());
// Give any log message handler first dibs on the message.
- if (log_message_handler &&
- log_message_handler(severity_, file_, line_,
- message_start_, str_newline)) {
+ if (log_message_handler && log_message_handler(severity_, file_, line_,
+ message_start_, str_newline)) {
// The handler took care of it, no further processing.
return;
}
@@ -603,9 +610,9 @@
// Map Chrome log severities to ASL log levels.
const char* const asl_level_string = [](LogSeverity severity) {
- // ASL_LEVEL_* are ints, but ASL needs equivalent strings. This
- // non-obvious two-step macro trick achieves what's needed.
- // https://gcc.gnu.org/onlinedocs/cpp/Stringification.html
+// ASL_LEVEL_* are ints, but ASL needs equivalent strings. This
+// non-obvious two-step macro trick achieves what's needed.
+// https://gcc.gnu.org/onlinedocs/cpp/Stringification.html
#define ASL_LEVEL_STR(level) ASL_LEVEL_STR_X(level)
#define ASL_LEVEL_STR_X(level) #level
switch (severity) {
@@ -677,13 +684,13 @@
// write to log file
if ((g_logging_destination & LOG_TO_FILE) != 0) {
- // We can have multiple threads and/or processes, so try to prevent them
- // from clobbering each other's writes.
- // If the client app did not call InitLogging, and the lock has not
- // been created do it now. We do this on demand, but if two threads try
- // to do this at the same time, there will be a race condition to create
- // the lock. This is why InitLogging should be called from the main
- // thread at the beginning of execution.
+// We can have multiple threads and/or processes, so try to prevent them
+// from clobbering each other's writes.
+// If the client app did not call InitLogging, and the lock has not
+// been created do it now. We do this on demand, but if two threads try
+// to do this at the same time, there will be a race condition to create
+// the lock. This is why InitLogging should be called from the main
+// thread at the beginning of execution.
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
LoggingLock::Init(LOCK_LOG_FILE, nullptr);
LoggingLock logging_lock;
@@ -691,14 +698,12 @@
if (InitializeLogFileHandle()) {
#if defined(OS_WIN)
DWORD num_written;
- WriteFile(g_log_file,
- static_cast<const void*>(str_newline.c_str()),
- static_cast<DWORD>(str_newline.length()),
- &num_written,
+ WriteFile(g_log_file, static_cast<const void*>(str_newline.c_str()),
+ static_cast<DWORD>(str_newline.length()), &num_written,
nullptr);
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- ignore_result(fwrite(
- str_newline.data(), str_newline.size(), 1, g_log_file));
+ ignore_result(
+ fwrite(str_newline.data(), str_newline.size(), 1, g_log_file));
fflush(g_log_file);
#else
#error Unsupported platform
@@ -731,7 +736,7 @@
// TODO(darin): It might be nice if the columns were fixed width.
- stream_ << '[';
+ stream_ << '[';
if (g_log_process_id)
stream_ << CurrentProcessId() << ':';
if (g_log_thread_id)
@@ -740,17 +745,11 @@
#if defined(OS_WIN)
SYSTEMTIME local_time;
GetLocalTime(&local_time);
- stream_ << std::setfill('0')
- << std::setw(2) << local_time.wMonth
- << std::setw(2) << local_time.wDay
- << '/'
- << std::setw(2) << local_time.wHour
- << std::setw(2) << local_time.wMinute
- << std::setw(2) << local_time.wSecond
- << '.'
- << std::setw(3)
- << local_time.wMilliseconds
- << ':';
+ stream_ << std::setfill('0') << std::setw(2) << local_time.wMonth
+ << std::setw(2) << local_time.wDay << '/' << std::setw(2)
+ << local_time.wHour << std::setw(2) << local_time.wMinute
+ << std::setw(2) << local_time.wSecond << '.' << std::setw(3)
+ << local_time.wMilliseconds << ':';
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
timeval tv;
gettimeofday(&tv, nullptr);
@@ -758,16 +757,11 @@
struct tm local_time;
localtime_r(&t, &local_time);
struct tm* tm_time = &local_time;
- stream_ << std::setfill('0')
- << std::setw(2) << 1 + tm_time->tm_mon
- << std::setw(2) << tm_time->tm_mday
- << '/'
- << std::setw(2) << tm_time->tm_hour
- << std::setw(2) << tm_time->tm_min
- << std::setw(2) << tm_time->tm_sec
- << '.'
- << std::setw(6) << tv.tv_usec
- << ':';
+ stream_ << std::setfill('0') << std::setw(2) << 1 + tm_time->tm_mon
+ << std::setw(2) << tm_time->tm_mday << '/' << std::setw(2)
+ << tm_time->tm_hour << std::setw(2) << tm_time->tm_min
+ << std::setw(2) << tm_time->tm_sec << '.' << std::setw(6)
+ << tv.tv_usec << ':';
#else
#error Unsupported platform
#endif
@@ -819,15 +813,12 @@
#endif // defined(OS_WIN)
}
-
#if defined(OS_WIN)
Win32ErrorLogMessage::Win32ErrorLogMessage(const char* file,
int line,
LogSeverity severity,
SystemErrorCode err)
- : err_(err),
- log_message_(file, line, severity) {
-}
+ : err_(err), log_message_(file, line, severity) {}
Win32ErrorLogMessage::~Win32ErrorLogMessage() {
stream() << ": " << SystemErrorCodeToString(err_);
@@ -837,9 +828,7 @@
int line,
LogSeverity severity,
SystemErrorCode err)
- : err_(err),
- log_message_(file, line, severity) {
-}
+ : err_(err), log_message_(file, line, severity) {}
ErrnoLogMessage::~ErrnoLogMessage() {
stream() << ": " << SystemErrorCodeToString(err_);
@@ -859,9 +848,8 @@
const size_t message_len = strlen(message);
int rv;
while (bytes_written < message_len) {
- rv = HANDLE_EINTR(
- write(STDERR_FILENO, message + bytes_written,
- message_len - bytes_written));
+ rv = HANDLE_EINTR(write(STDERR_FILENO, message + bytes_written,
+ message_len - bytes_written));
if (rv < 0) {
// Give up, nothing we can do now.
break;
@@ -900,8 +888,7 @@
#endif
void LogErrorNotReached(const char* file, int line) {
- LogMessage(file, line, LOG_ERROR).stream()
- << "NOTREACHED() hit.";
+ LogMessage(file, line, LOG_ERROR).stream() << "NOTREACHED() hit.";
}
} // namespace logging
diff --git a/base/logging.h b/base/logging.h
index 36eb271..3fb3778 100644
--- a/base/logging.h
+++ b/base/logging.h
@@ -45,7 +45,6 @@
// If DebugMessage.exe is not found, the logging code will use a normal
// MessageBox, potentially causing the problems discussed above.
-
// Instructions
// ------------
//
@@ -114,15 +113,15 @@
// Where to record logging output? A flat file and/or system debug log
// via OutputDebugString.
enum LoggingDestination {
- LOG_NONE = 0,
- LOG_TO_FILE = 1 << 0,
+ LOG_NONE = 0,
+ LOG_TO_FILE = 1 << 0,
LOG_TO_SYSTEM_DEBUG_LOG = 1 << 1,
LOG_TO_ALL = LOG_TO_FILE | LOG_TO_SYSTEM_DEBUG_LOG,
- // On Windows, use a file next to the exe; on POSIX platforms, where
- // it may not even be possible to locate the executable on disk, use
- // stderr.
+// On Windows, use a file next to the exe; on POSIX platforms, where
+// it may not even be possible to locate the executable on disk, use
+// stderr.
#if defined(OS_WIN)
LOG_DEFAULT = LOG_TO_FILE,
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
@@ -210,8 +209,10 @@
// process and thread IDs default to off, the timestamp defaults to on.
// If this function is not called, logging defaults to writing the timestamp
// only.
-void SetLogItems(bool enable_process_id, bool enable_thread_id,
- bool enable_timestamp, bool enable_tickcount);
+void SetLogItems(bool enable_process_id,
+ bool enable_thread_id,
+ bool enable_timestamp,
+ bool enable_tickcount);
// Sets whether or not you'd like to see fatal debug messages popped up in
// a dialog box or not.
@@ -223,7 +224,10 @@
// Returns true to signal that it handled the message and the message
// should not be sent to other log destinations.
typedef bool (*LogMessageHandlerFunction)(int severity,
- const char* file, int line, size_t message_start, const std::string& str);
+ const char* file,
+ int line,
+ size_t message_start,
+ const std::string& str);
void SetLogMessageHandler(LogMessageHandlerFunction handler);
LogMessageHandlerFunction GetLogMessageHandler();
@@ -308,7 +312,7 @@
// the Windows SDK does for consistency.
#define ERROR 0
#define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \
- COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__)
+ COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR
// Needed for LOG_IS_ON(ERROR).
const LogSeverity LOG_0 = LOG_ERROR;
@@ -322,8 +326,8 @@
// Helper macro which avoids evaluating the arguments to a stream if
// the condition doesn't hold. Condition is evaluated once and only once.
-#define LAZY_STREAM(stream, condition) \
- !(condition) ? (void) 0 : ::logging::LogMessageVoidify() & (stream)
+#define LAZY_STREAM(stream, condition) \
+ !(condition) ? (void)0 : ::logging::LogMessageVoidify() & (stream)
// We use the preprocessor's merging operator, "##", so that, e.g.,
// LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO. There's some funny
@@ -333,7 +337,7 @@
// impossible to stream something like a string directly to an unnamed
// ostream. We employ a neat hack by calling the stream() member
// function of LogMessage which seems to avoid the problem.
-#define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_ ## severity.stream()
+#define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_##severity.stream()
#define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity))
#define LOG_IF(severity, condition) \
@@ -344,17 +348,18 @@
<< "Assert failed: " #condition ". "
#if defined(OS_WIN)
-#define PLOG_STREAM(severity) \
- COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \
- ::logging::GetLastSystemErrorCode()).stream()
+#define PLOG_STREAM(severity) \
+ COMPACT_GOOGLE_LOG_EX_##severity(Win32ErrorLogMessage, \
+ ::logging::GetLastSystemErrorCode()) \
+ .stream()
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#define PLOG_STREAM(severity) \
- COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \
- ::logging::GetLastSystemErrorCode()).stream()
+#define PLOG_STREAM(severity) \
+ COMPACT_GOOGLE_LOG_EX_##severity(ErrnoLogMessage, \
+ ::logging::GetLastSystemErrorCode()) \
+ .stream()
#endif
-#define PLOG(severity) \
- LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
+#define PLOG(severity) LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
#define PLOG_IF(severity, condition) \
LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
@@ -517,7 +522,7 @@
LAZY_STREAM(PLOG_STREAM(FATAL), UNLIKELY(!(condition))); \
EAT_STREAM_PARAMETERS
-#define CHECK_OP(name, op, val1, val2) CHECK((val1) op (val2))
+#define CHECK_OP(name, op, val1, val2) CHECK((val1)op(val2))
#else // !(OFFICIAL_BUILD && NDEBUG)
@@ -529,15 +534,13 @@
// __analysis_assume gets confused on some conditions:
// http://randomascii.wordpress.com/2011/09/13/analyze-for-visual-studio-the-ugly-part-5/
-#define CHECK(condition) \
- __analysis_assume(!!(condition)), \
- LAZY_STREAM(LOG_STREAM(FATAL), false) \
- << "Check failed: " #condition ". "
+#define CHECK(condition) \
+ __analysis_assume(!!(condition)), LAZY_STREAM(LOG_STREAM(FATAL), false) \
+ << "Check failed: " #condition ". "
-#define PCHECK(condition) \
- __analysis_assume(!!(condition)), \
- LAZY_STREAM(PLOG_STREAM(FATAL), false) \
- << "Check failed: " #condition ". "
+#define PCHECK(condition) \
+ __analysis_assume(!!(condition)), LAZY_STREAM(PLOG_STREAM(FATAL), false) \
+ << "Check failed: " #condition ". "
#else // _PREFAST_
@@ -558,14 +561,17 @@
// macro is used in an 'if' clause such as:
// if (a == 1)
// CHECK_EQ(2, a);
-#define CHECK_OP(name, op, val1, val2) \
- switch (0) case 0: default: \
- if (::logging::CheckOpResult true_if_passed = \
- ::logging::Check##name##Impl((val1), (val2), \
- #val1 " " #op " " #val2)) \
- ; \
- else \
- ::logging::LogMessage(__FILE__, __LINE__, true_if_passed.message()).stream()
+#define CHECK_OP(name, op, val1, val2) \
+ switch (0) \
+ case 0: \
+ default: \
+ if (::logging::CheckOpResult true_if_passed = \
+ ::logging::Check##name##Impl((val1), (val2), \
+ #val1 " " #op " " #val2)) \
+ ; \
+ else \
+ ::logging::LogMessage(__FILE__, __LINE__, true_if_passed.message()) \
+ .stream()
#endif // !(OFFICIAL_BUILD && NDEBUG)
@@ -611,7 +617,7 @@
// function template because it is not performance critical and so can
// be out of line, while the "Impl" code should be inline. Caller
// takes ownership of the returned string.
-template<class t1, class t2>
+template <class t1, class t2>
std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) {
std::ostringstream ss;
ss << names << " (";
@@ -625,20 +631,25 @@
// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
// in logging.cc.
-extern template std::string* MakeCheckOpString<int, int>(
- const int&, const int&, const char* names);
-extern template
-std::string* MakeCheckOpString<unsigned long, unsigned long>(
- const unsigned long&, const unsigned long&, const char* names);
-extern template
-std::string* MakeCheckOpString<unsigned long, unsigned int>(
- const unsigned long&, const unsigned int&, const char* names);
-extern template
-std::string* MakeCheckOpString<unsigned int, unsigned long>(
- const unsigned int&, const unsigned long&, const char* names);
-extern template
-std::string* MakeCheckOpString<std::string, std::string>(
- const std::string&, const std::string&, const char* name);
+extern template std::string* MakeCheckOpString<int, int>(const int&,
+ const int&,
+ const char* names);
+extern template std::string* MakeCheckOpString<unsigned long, unsigned long>(
+ const unsigned long&,
+ const unsigned long&,
+ const char* names);
+extern template std::string* MakeCheckOpString<unsigned long, unsigned int>(
+ const unsigned long&,
+ const unsigned int&,
+ const char* names);
+extern template std::string* MakeCheckOpString<unsigned int, unsigned long>(
+ const unsigned int&,
+ const unsigned long&,
+ const char* names);
+extern template std::string* MakeCheckOpString<std::string, std::string>(
+ const std::string&,
+ const std::string&,
+ const char* name);
// Helper functions for CHECK_OP macro.
// The (int, int) specialization works around the issue that the compiler
@@ -666,17 +677,17 @@
DEFINE_CHECK_OP_IMPL(EQ, ==)
DEFINE_CHECK_OP_IMPL(NE, !=)
DEFINE_CHECK_OP_IMPL(LE, <=)
-DEFINE_CHECK_OP_IMPL(LT, < )
+DEFINE_CHECK_OP_IMPL(LT, <)
DEFINE_CHECK_OP_IMPL(GE, >=)
-DEFINE_CHECK_OP_IMPL(GT, > )
+DEFINE_CHECK_OP_IMPL(GT, >)
#undef DEFINE_CHECK_OP_IMPL
#define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2)
#define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2)
#define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2)
-#define CHECK_LT(val1, val2) CHECK_OP(LT, < , val1, val2)
+#define CHECK_LT(val1, val2) CHECK_OP(LT, <, val1, val2)
#define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2)
-#define CHECK_GT(val1, val2) CHECK_OP(GT, > , val1, val2)
+#define CHECK_GT(val1, val2) CHECK_OP(GT, >, val1, val2)
#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
#define DCHECK_IS_ON() 0
@@ -706,11 +717,9 @@
#endif // DCHECK_IS_ON()
-#define DLOG(severity) \
- LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
+#define DLOG(severity) LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
-#define DPLOG(severity) \
- LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
+#define DPLOG(severity) LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
// Definitions for DCHECK et al.
@@ -742,15 +751,13 @@
#if defined(_PREFAST_) && defined(OS_WIN)
// See comments on the previous use of __analysis_assume.
-#define DCHECK(condition) \
- __analysis_assume(!!(condition)), \
- LAZY_STREAM(LOG_STREAM(DCHECK), false) \
- << "Check failed: " #condition ". "
+#define DCHECK(condition) \
+ __analysis_assume(!!(condition)), LAZY_STREAM(LOG_STREAM(DCHECK), false) \
+ << "Check failed: " #condition ". "
-#define DPCHECK(condition) \
- __analysis_assume(!!(condition)), \
- LAZY_STREAM(PLOG_STREAM(DCHECK), false) \
- << "Check failed: " #condition ". "
+#define DPCHECK(condition) \
+ __analysis_assume(!!(condition)), LAZY_STREAM(PLOG_STREAM(DCHECK), false) \
+ << "Check failed: " #condition ". "
#else // !(defined(_PREFAST_) && defined(OS_WIN))
@@ -780,16 +787,19 @@
// DCHECK_EQ(2, a);
#if DCHECK_IS_ON()
-#define DCHECK_OP(name, op, val1, val2) \
- switch (0) case 0: default: \
- if (::logging::CheckOpResult true_if_passed = \
- DCHECK_IS_ON() ? \
- ::logging::Check##name##Impl((val1), (val2), \
- #val1 " " #op " " #val2) : nullptr) \
- ; \
- else \
- ::logging::LogMessage(__FILE__, __LINE__, ::logging::LOG_DCHECK, \
- true_if_passed.message()).stream()
+#define DCHECK_OP(name, op, val1, val2) \
+ switch (0) \
+ case 0: \
+ default: \
+ if (::logging::CheckOpResult true_if_passed = \
+ DCHECK_IS_ON() ? ::logging::Check##name##Impl( \
+ (val1), (val2), #val1 " " #op " " #val2) \
+ : nullptr) \
+ ; \
+ else \
+ ::logging::LogMessage(__FILE__, __LINE__, ::logging::LOG_DCHECK, \
+ true_if_passed.message()) \
+ .stream()
#else // DCHECK_IS_ON()
@@ -833,9 +843,9 @@
#define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2)
#define DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2)
#define DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2)
-#define DCHECK_LT(val1, val2) DCHECK_OP(LT, < , val1, val2)
+#define DCHECK_LT(val1, val2) DCHECK_OP(LT, <, val1, val2)
#define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2)
-#define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2)
+#define DCHECK_GT(val1, val2) DCHECK_OP(GT, >, val1, val2)
#if !DCHECK_IS_ON() && defined(OS_CHROMEOS)
// Implement logging of NOTREACHED() as a dedicated function to get function
@@ -873,7 +883,9 @@
LogMessage(const char* file, int line, std::string* result);
// Used for DCHECK_EQ(), etc. Takes ownership of the given string.
- LogMessage(const char* file, int line, LogSeverity severity,
+ LogMessage(const char* file,
+ int line,
+ LogSeverity severity,
std::string* result);
~LogMessage();
@@ -925,7 +937,7 @@
LogMessageVoidify() = default;
// This has to be an operator with a precedence lower than << but
// higher than ?:
- void operator&(std::ostream&) { }
+ void operator&(std::ostream&) {}
};
#if defined(OS_WIN)
diff --git a/base/mac/bind_objc_block.h b/base/mac/bind_objc_block.h
index 9a481ed..87d38bf 100644
--- a/base/mac/bind_objc_block.h
+++ b/base/mac/bind_objc_block.h
@@ -41,9 +41,9 @@
namespace internal {
// Helper function to run the block contained in the parameter.
-template<typename R, typename... Args>
-R RunBlock(base::mac::ScopedBlock<R(^)(Args...)> block, Args... args) {
- R(^extracted_block)(Args...) = block.get();
+template <typename R, typename... Args>
+R RunBlock(base::mac::ScopedBlock<R (^)(Args...)> block, Args... args) {
+ R (^extracted_block)(Args...) = block.get();
return extracted_block(args...);
}
@@ -53,8 +53,8 @@
// Construct a callback from an objective-C block with up to six arguments (see
// note above).
-template<typename R, typename... Args>
-base::Callback<R(Args...)> BindBlock(R(^block)(Args...)) {
+template <typename R, typename... Args>
+base::Callback<R(Args...)> BindBlock(R (^block)(Args...)) {
return base::Bind(
&base::internal::RunBlock<R, Args...>,
base::mac::ScopedBlock<R (^)(Args...)>(
diff --git a/base/mac/bundle_locations.h b/base/mac/bundle_locations.h
index 86ff1a4..2bda76e 100644
--- a/base/mac/bundle_locations.h
+++ b/base/mac/bundle_locations.h
@@ -9,7 +9,7 @@
#if defined(__OBJC__)
#import <Foundation/Foundation.h>
-#else // __OBJC__
+#else // __OBJC__
class NSBundle;
#endif // __OBJC__
diff --git a/base/mac/dispatch_source_mach.cc b/base/mac/dispatch_source_mach.cc
index 0858f30..50da7e4 100644
--- a/base/mac/dispatch_source_mach.cc
+++ b/base/mac/dispatch_source_mach.cc
@@ -24,11 +24,13 @@
void (^event_handler)())
: queue_(queue, base::scoped_policy::RETAIN),
source_(dispatch_source_create(DISPATCH_SOURCE_TYPE_MACH_RECV,
- port, 0, queue_)),
+ port,
+ 0,
+ queue_)),
source_canceled_(dispatch_semaphore_create(0)) {
dispatch_source_set_event_handler(source_, event_handler);
dispatch_source_set_cancel_handler(source_, ^{
- dispatch_semaphore_signal(source_canceled_);
+ dispatch_semaphore_signal(source_canceled_);
});
}
diff --git a/base/mac/foundation_util.h b/base/mac/foundation_util.h
index 29f281b..c5cead4 100644
--- a/base/mac/foundation_util.h
+++ b/base/mac/foundation_util.h
@@ -35,8 +35,9 @@
// Adapted from NSObjCRuntime.h NS_ENUM definition (used in Foundation starting
// with the OS X 10.8 SDK and the iOS 6.0 SDK).
#if __has_extension(cxx_strong_enums) && \
- (defined(OS_IOS) || (defined(MAC_OS_X_VERSION_10_8) && \
- MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_8))
+ (defined(OS_IOS) || \
+ (defined(MAC_OS_X_VERSION_10_8) && \
+ MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_8))
#define CR_FORWARD_ENUM(_type, _name) enum _name : _type _name
#else
#define CR_FORWARD_ENUM(_type, _name) _type _name
@@ -102,20 +103,18 @@
// If found, fills result (which must always be non-NULL) with the
// first found directory and returns true. Otherwise, returns false.
bool GetSearchPathDirectory(NSSearchPathDirectory directory,
- NSSearchPathDomainMask domain_mask,
- FilePath* result);
+ NSSearchPathDomainMask domain_mask,
+ FilePath* result);
// Searches for directories for the given key in only the local domain.
// If found, fills result (which must always be non-NULL) with the
// first found directory and returns true. Otherwise, returns false.
-bool GetLocalDirectory(NSSearchPathDirectory directory,
- FilePath* result);
+bool GetLocalDirectory(NSSearchPathDirectory directory, FilePath* result);
// Searches for directories for the given key in only the user domain.
// If found, fills result (which must always be non-NULL) with the
// first found directory and returns true. Otherwise, returns false.
-bool GetUserDirectory(NSSearchPathDirectory directory,
- FilePath* result);
+bool GetUserDirectory(NSSearchPathDirectory directory, FilePath* result);
// Returns the ~/Library directory.
FilePath GetUserLibraryPath();
@@ -128,7 +127,7 @@
FilePath GetAppBundlePath(const FilePath& exec_name);
#define TYPE_NAME_FOR_CF_TYPE_DECL(TypeCF) \
-std::string TypeNameForCFType(TypeCF##Ref);
+ std::string TypeNameForCFType(TypeCF##Ref);
TYPE_NAME_FOR_CF_TYPE_DECL(CFArray);
TYPE_NAME_FOR_CF_TYPE_DECL(CFBag);
@@ -208,25 +207,25 @@
// of macros and function overloading is used instead.
#define CF_TO_NS_CAST_DECL(TypeCF, TypeNS) \
-OBJC_CPP_CLASS_DECL(TypeNS) \
-\
-namespace base { \
-namespace mac { \
-TypeNS* CFToNSCast(TypeCF##Ref cf_val); \
-TypeCF##Ref NSToCFCast(TypeNS* ns_val); \
-} \
-}
+ OBJC_CPP_CLASS_DECL(TypeNS) \
+ \
+ namespace base { \
+ namespace mac { \
+ TypeNS* CFToNSCast(TypeCF##Ref cf_val); \
+ TypeCF##Ref NSToCFCast(TypeNS* ns_val); \
+ } \
+ }
-#define CF_TO_NS_MUTABLE_CAST_DECL(name) \
-CF_TO_NS_CAST_DECL(CF##name, NS##name) \
-OBJC_CPP_CLASS_DECL(NSMutable##name) \
-\
-namespace base { \
-namespace mac { \
-NSMutable##name* CFToNSCast(CFMutable##name##Ref cf_val); \
-CFMutable##name##Ref NSToCFCast(NSMutable##name* ns_val); \
-} \
-}
+#define CF_TO_NS_MUTABLE_CAST_DECL(name) \
+ CF_TO_NS_CAST_DECL(CF##name, NS##name) \
+ OBJC_CPP_CLASS_DECL(NSMutable##name) \
+ \
+ namespace base { \
+ namespace mac { \
+ NSMutable##name* CFToNSCast(CFMutable##name##Ref cf_val); \
+ CFMutable##name##Ref NSToCFCast(NSMutable##name* ns_val); \
+ } \
+ }
// List of toll-free bridged types taken from:
// http://www.cocoadev.com/index.pl?TollFreeBridged
@@ -278,18 +277,18 @@
// CFTypeRef hello = CFSTR("hello world");
// CFStringRef some_string = base::mac::CFCastStrict<CFStringRef>(hello);
-template<typename T>
+template <typename T>
T CFCast(const CFTypeRef& cf_val);
-template<typename T>
+template <typename T>
T CFCastStrict(const CFTypeRef& cf_val);
-#define CF_CAST_DECL(TypeCF) \
-template<> TypeCF##Ref \
-CFCast<TypeCF##Ref>(const CFTypeRef& cf_val);\
-\
-template<> TypeCF##Ref \
-CFCastStrict<TypeCF##Ref>(const CFTypeRef& cf_val);
+#define CF_CAST_DECL(TypeCF) \
+ template <> \
+ TypeCF##Ref CFCast<TypeCF##Ref>(const CFTypeRef& cf_val); \
+ \
+ template <> \
+ TypeCF##Ref CFCastStrict<TypeCF##Ref>(const CFTypeRef& cf_val);
CF_CAST_DECL(CFArray);
CF_CAST_DECL(CFBag);
@@ -341,7 +340,7 @@
//
// NSString* str = base::mac::ObjCCastStrict<NSString>(
// [ns_arr_of_ns_strs objectAtIndex:0]);
-template<typename T>
+template <typename T>
T* ObjCCast(id objc_val) {
if ([objc_val isKindOfClass:[T class]]) {
return reinterpret_cast<T*>(objc_val);
@@ -349,7 +348,7 @@
return nil;
}
-template<typename T>
+template <typename T>
T* ObjCCastStrict(id objc_val) {
T* rv = ObjCCast<T>(objc_val);
DCHECK(objc_val == nil || rv);
@@ -360,20 +359,20 @@
// Helper function for GetValueFromDictionary to create the error message
// that appears when a type mismatch is encountered.
-std::string GetValueFromDictionaryErrorMessage(
- CFStringRef key, const std::string& expected_type, CFTypeRef value);
+std::string GetValueFromDictionaryErrorMessage(CFStringRef key,
+ const std::string& expected_type,
+ CFTypeRef value);
// Utility function to pull out a value from a dictionary, check its type, and
// return it. Returns NULL if the key is not present or of the wrong type.
-template<typename T>
+template <typename T>
T GetValueFromDictionary(CFDictionaryRef dict, CFStringRef key) {
CFTypeRef value = CFDictionaryGetValue(dict, key);
T value_specific = CFCast<T>(value);
if (value && !value_specific) {
std::string expected_type = TypeNameForCFType(value_specific);
- DLOG(WARNING) << GetValueFromDictionaryErrorMessage(key,
- expected_type,
+ DLOG(WARNING) << GetValueFromDictionaryErrorMessage(key, expected_type,
value);
}
@@ -390,8 +389,7 @@
// Converts |range| to an NSRange, returning the new range in |range_out|.
// Returns true if conversion was successful, false if the values of |range|
// could not be converted to NSUIntegers.
-bool CFRangeToNSRange(CFRange range,
- NSRange* range_out) WARN_UNUSED_RESULT;
+bool CFRangeToNSRange(CFRange range, NSRange* range_out) WARN_UNUSED_RESULT;
#endif // defined(__OBJC__)
} // namespace mac
@@ -402,9 +400,7 @@
// e.g. LOG(INFO) << base::mac::NSToCFCast(@"foo");
// Operator << can not be overloaded for ObjectiveC types as the compiler
// can not distinguish between overloads for id with overloads for void*.
-extern std::ostream& operator<<(std::ostream& o,
- const CFErrorRef err);
-extern std::ostream& operator<<(std::ostream& o,
- const CFStringRef str);
+extern std::ostream& operator<<(std::ostream& o, const CFErrorRef err);
+extern std::ostream& operator<<(std::ostream& o, const CFStringRef str);
#endif // BASE_MAC_FOUNDATION_UTIL_H_
diff --git a/base/mac/foundation_util.mm b/base/mac/foundation_util.mm
index a0c5cec..1fb91a9 100644
--- a/base/mac/foundation_util.mm
+++ b/base/mac/foundation_util.mm
@@ -94,8 +94,8 @@
FilePath PathForFrameworkBundleResource(CFStringRef resourceName) {
NSBundle* bundle = base::mac::FrameworkBundle();
- NSString* resourcePath = [bundle pathForResource:(NSString*)resourceName
- ofType:nil];
+ NSString* resourcePath =
+ [bundle pathForResource:(NSString*)resourceName ofType:nil];
return NSStringToFilePath(resourcePath);
}
@@ -192,9 +192,7 @@
}
#define TYPE_NAME_FOR_CF_TYPE_DEFN(TypeCF) \
-std::string TypeNameForCFType(TypeCF##Ref) { \
- return #TypeCF; \
-}
+ std::string TypeNameForCFType(TypeCF##Ref) { return #TypeCF; }
TYPE_NAME_FOR_CF_TYPE_DEFN(CFArray);
TYPE_NAME_FOR_CF_TYPE_DEFN(CFBag);
@@ -222,12 +220,12 @@
#undef TYPE_NAME_FOR_CF_TYPE_DEFN
void NSObjectRetain(void* obj) {
- id<NSObject> nsobj = static_cast<id<NSObject> >(obj);
+ id<NSObject> nsobj = static_cast<id<NSObject>>(obj);
[nsobj retain];
}
void NSObjectRelease(void* obj) {
- id<NSObject> nsobj = static_cast<id<NSObject> >(obj);
+ id<NSObject> nsobj = static_cast<id<NSObject>>(obj);
[nsobj release];
}
@@ -265,36 +263,36 @@
// Definitions for the corresponding CF_TO_NS_CAST_DECL macros in
// foundation_util.h.
-#define CF_TO_NS_CAST_DEFN(TypeCF, TypeNS) \
-\
-TypeNS* CFToNSCast(TypeCF##Ref cf_val) { \
- DCHECK(!cf_val || TypeCF##GetTypeID() == CFGetTypeID(cf_val)); \
- TypeNS* ns_val = \
- const_cast<TypeNS*>(reinterpret_cast<const TypeNS*>(cf_val)); \
- return ns_val; \
-} \
-\
-TypeCF##Ref NSToCFCast(TypeNS* ns_val) { \
- TypeCF##Ref cf_val = reinterpret_cast<TypeCF##Ref>(ns_val); \
- DCHECK(!cf_val || TypeCF##GetTypeID() == CFGetTypeID(cf_val)); \
- return cf_val; \
-}
+#define CF_TO_NS_CAST_DEFN(TypeCF, TypeNS) \
+ \
+ TypeNS* CFToNSCast(TypeCF##Ref cf_val) { \
+ DCHECK(!cf_val || TypeCF##GetTypeID() == CFGetTypeID(cf_val)); \
+ TypeNS* ns_val = \
+ const_cast<TypeNS*>(reinterpret_cast<const TypeNS*>(cf_val)); \
+ return ns_val; \
+ } \
+ \
+ TypeCF##Ref NSToCFCast(TypeNS* ns_val) { \
+ TypeCF##Ref cf_val = reinterpret_cast<TypeCF##Ref>(ns_val); \
+ DCHECK(!cf_val || TypeCF##GetTypeID() == CFGetTypeID(cf_val)); \
+ return cf_val; \
+ }
-#define CF_TO_NS_MUTABLE_CAST_DEFN(name) \
-CF_TO_NS_CAST_DEFN(CF##name, NS##name) \
-\
-NSMutable##name* CFToNSCast(CFMutable##name##Ref cf_val) { \
- DCHECK(!cf_val || CF##name##GetTypeID() == CFGetTypeID(cf_val)); \
- NSMutable##name* ns_val = reinterpret_cast<NSMutable##name*>(cf_val); \
- return ns_val; \
-} \
-\
-CFMutable##name##Ref NSToCFCast(NSMutable##name* ns_val) { \
- CFMutable##name##Ref cf_val = \
- reinterpret_cast<CFMutable##name##Ref>(ns_val); \
- DCHECK(!cf_val || CF##name##GetTypeID() == CFGetTypeID(cf_val)); \
- return cf_val; \
-}
+#define CF_TO_NS_MUTABLE_CAST_DEFN(name) \
+ CF_TO_NS_CAST_DEFN(CF##name, NS##name) \
+ \
+ NSMutable##name* CFToNSCast(CFMutable##name##Ref cf_val) { \
+ DCHECK(!cf_val || CF##name##GetTypeID() == CFGetTypeID(cf_val)); \
+ NSMutable##name* ns_val = reinterpret_cast<NSMutable##name*>(cf_val); \
+ return ns_val; \
+ } \
+ \
+ CFMutable##name##Ref NSToCFCast(NSMutable##name* ns_val) { \
+ CFMutable##name##Ref cf_val = \
+ reinterpret_cast<CFMutable##name##Ref>(ns_val); \
+ DCHECK(!cf_val || CF##name##GetTypeID() == CFGetTypeID(cf_val)); \
+ return cf_val; \
+ }
CF_TO_NS_MUTABLE_CAST_DEFN(Array);
CF_TO_NS_MUTABLE_CAST_DEFN(AttributedString);
@@ -321,10 +319,8 @@
// checking, so do some special-casing.
// http://www.openradar.me/15341349 rdar://15341349
NSFont* CFToNSCast(CTFontRef cf_val) {
- NSFont* ns_val =
- const_cast<NSFont*>(reinterpret_cast<const NSFont*>(cf_val));
- DCHECK(!cf_val ||
- CTFontGetTypeID() == CFGetTypeID(cf_val) ||
+ NSFont* ns_val = const_cast<NSFont*>(reinterpret_cast<const NSFont*>(cf_val));
+ DCHECK(!cf_val || CTFontGetTypeID() == CFGetTypeID(cf_val) ||
(_CFIsObjC(CTFontGetTypeID(), cf_val) &&
[ns_val isKindOfClass:[NSFont class]]));
return ns_val;
@@ -332,8 +328,7 @@
CTFontRef NSToCFCast(NSFont* ns_val) {
CTFontRef cf_val = reinterpret_cast<CTFontRef>(ns_val);
- DCHECK(!cf_val ||
- CTFontGetTypeID() == CFGetTypeID(cf_val) ||
+ DCHECK(!cf_val || CTFontGetTypeID() == CFGetTypeID(cf_val) ||
[ns_val isKindOfClass:[NSFont class]]);
return cf_val;
}
@@ -342,24 +337,24 @@
#undef CF_TO_NS_CAST_DEFN
#undef CF_TO_NS_MUTABLE_CAST_DEFN
-#define CF_CAST_DEFN(TypeCF) \
-template<> TypeCF##Ref \
-CFCast<TypeCF##Ref>(const CFTypeRef& cf_val) { \
- if (cf_val == NULL) { \
- return NULL; \
- } \
- if (CFGetTypeID(cf_val) == TypeCF##GetTypeID()) { \
- return (TypeCF##Ref)(cf_val); \
- } \
- return NULL; \
-} \
-\
-template<> TypeCF##Ref \
-CFCastStrict<TypeCF##Ref>(const CFTypeRef& cf_val) { \
- TypeCF##Ref rv = CFCast<TypeCF##Ref>(cf_val); \
- DCHECK(cf_val == NULL || rv); \
- return rv; \
-}
+#define CF_CAST_DEFN(TypeCF) \
+ template <> \
+ TypeCF##Ref CFCast<TypeCF##Ref>(const CFTypeRef& cf_val) { \
+ if (cf_val == NULL) { \
+ return NULL; \
+ } \
+ if (CFGetTypeID(cf_val) == TypeCF##GetTypeID()) { \
+ return (TypeCF##Ref)(cf_val); \
+ } \
+ return NULL; \
+ } \
+ \
+ template <> \
+ TypeCF##Ref CFCastStrict<TypeCF##Ref>(const CFTypeRef& cf_val) { \
+ TypeCF##Ref rv = CFCast<TypeCF##Ref>(cf_val); \
+ DCHECK(cf_val == NULL || rv); \
+ return rv; \
+ }
CF_CAST_DEFN(CFArray);
CF_CAST_DEFN(CFBag);
@@ -385,8 +380,8 @@
// The NSFont/CTFont toll-free bridging is broken when it comes to type
// checking, so do some special-casing.
// http://www.openradar.me/15341349 rdar://15341349
-template<> CTFontRef
-CFCast<CTFontRef>(const CFTypeRef& cf_val) {
+template <>
+CTFontRef CFCast<CTFontRef>(const CFTypeRef& cf_val) {
if (cf_val == NULL) {
return NULL;
}
@@ -404,8 +399,8 @@
return NULL;
}
-template<> CTFontRef
-CFCastStrict<CTFontRef>(const CFTypeRef& cf_val) {
+template <>
+CTFontRef CFCastStrict<CTFontRef>(const CFTypeRef& cf_val) {
CTFontRef rv = CFCast<CTFontRef>(cf_val);
DCHECK(cf_val == NULL || rv);
return rv;
@@ -421,17 +416,14 @@
#undef CF_CAST_DEFN
-std::string GetValueFromDictionaryErrorMessage(
- CFStringRef key, const std::string& expected_type, CFTypeRef value) {
+std::string GetValueFromDictionaryErrorMessage(CFStringRef key,
+ const std::string& expected_type,
+ CFTypeRef value) {
ScopedCFTypeRef<CFStringRef> actual_type_ref(
CFCopyTypeIDDescription(CFGetTypeID(value)));
- return "Expected value for key " +
- base::SysCFStringRefToUTF8(key) +
- " to be " +
- expected_type +
- " but it was " +
- base::SysCFStringRefToUTF8(actual_type_ref) +
- " instead";
+ return "Expected value for key " + base::SysCFStringRefToUTF8(key) +
+ " to be " + expected_type + " but it was " +
+ base::SysCFStringRefToUTF8(actual_type_ref) + " instead";
}
NSString* FilePathToNSString(const FilePath& path) {
@@ -474,10 +466,9 @@
errorDesc = reinterpret_cast<CFStringRef>(
CFDictionaryGetValue(user_info.get(), kCFErrorDescriptionKey));
}
- o << "Code: " << CFErrorGetCode(err)
- << " Domain: " << CFErrorGetDomain(err)
+ o << "Code: " << CFErrorGetCode(err) << " Domain: " << CFErrorGetDomain(err)
<< " Desc: " << desc.get();
- if(errorDesc) {
+ if (errorDesc) {
o << "(" << errorDesc << ")";
}
return o;
diff --git a/base/mac/mac_logging.h b/base/mac/mac_logging.h
index 148b383..9891d69 100644
--- a/base/mac/mac_logging.h
+++ b/base/mac/mac_logging.h
@@ -48,23 +48,23 @@
} // namespace logging
#define OSSTATUS_LOG_STREAM(severity, status) \
- COMPACT_GOOGLE_LOG_EX_ ## severity(OSStatusLogMessage, status).stream()
+ COMPACT_GOOGLE_LOG_EX_##severity(OSStatusLogMessage, status).stream()
#define OSSTATUS_LOG(severity, status) \
- LAZY_STREAM(OSSTATUS_LOG_STREAM(severity, status), LOG_IS_ON(severity))
+ LAZY_STREAM(OSSTATUS_LOG_STREAM(severity, status), LOG_IS_ON(severity))
#define OSSTATUS_LOG_IF(severity, condition, status) \
- LAZY_STREAM(OSSTATUS_LOG_STREAM(severity, status), \
- LOG_IS_ON(severity) && (condition))
+ LAZY_STREAM(OSSTATUS_LOG_STREAM(severity, status), \
+ LOG_IS_ON(severity) && (condition))
-#define OSSTATUS_CHECK(condition, status) \
- LAZY_STREAM(OSSTATUS_LOG_STREAM(FATAL, status), !(condition)) \
- << "Check failed: " # condition << ". "
+#define OSSTATUS_CHECK(condition, status) \
+ LAZY_STREAM(OSSTATUS_LOG_STREAM(FATAL, status), !(condition)) \
+ << "Check failed: " #condition << ". "
#define OSSTATUS_DLOG(severity, status) \
- LAZY_STREAM(OSSTATUS_LOG_STREAM(severity, status), DLOG_IS_ON(severity))
+ LAZY_STREAM(OSSTATUS_LOG_STREAM(severity, status), DLOG_IS_ON(severity))
#define OSSTATUS_DLOG_IF(severity, condition, status) \
- LAZY_STREAM(OSSTATUS_LOG_STREAM(severity, status), \
- DLOG_IS_ON(severity) && (condition))
+ LAZY_STREAM(OSSTATUS_LOG_STREAM(severity, status), \
+ DLOG_IS_ON(severity) && (condition))
#define OSSTATUS_DCHECK(condition, status) \
LAZY_STREAM(OSSTATUS_LOG_STREAM(FATAL, status), \
diff --git a/base/mac/mac_logging.mm b/base/mac/mac_logging.mm
index 1f9682d..ff311e3 100644
--- a/base/mac/mac_logging.mm
+++ b/base/mac/mac_logging.mm
@@ -26,9 +26,7 @@
int line,
LogSeverity severity,
OSStatus status)
- : LogMessage(file_path, line, severity),
- status_(status) {
-}
+ : LogMessage(file_path, line, severity), status_(status) {}
OSStatusLogMessage::~OSStatusLogMessage() {
#if defined(OS_IOS)
@@ -36,10 +34,7 @@
// to try to get a description of the failure.
stream() << ": " << status_;
#else
- stream() << ": "
- << DescriptionFromOSStatus(status_)
- << " ("
- << status_
+ stream() << ": " << DescriptionFromOSStatus(status_) << " (" << status_
<< ")";
#endif
}
diff --git a/base/mac/mac_util.h b/base/mac/mac_util.h
index 96dda1d..c4fcd33 100644
--- a/base/mac/mac_util.h
+++ b/base/mac/mac_util.h
@@ -10,7 +10,6 @@
#import <CoreGraphics/CoreGraphics.h>
-
namespace base {
class FilePath;
@@ -59,8 +58,7 @@
// Convenience method to switch the current fullscreen mode. This has the same
// net effect as a ReleaseFullScreen(from_mode) call followed immediately by a
// RequestFullScreen(to_mode). Must be called on the main thread.
-void SwitchFullScreenModes(FullScreenMode from_mode,
- FullScreenMode to_mode);
+void SwitchFullScreenModes(FullScreenMode from_mode, FullScreenMode to_mode);
// Excludes the file given by |file_path| from being backed up by Time Machine.
bool SetFileBackupExclusion(const FilePath& file_path);
@@ -171,9 +169,9 @@
// Parse a model identifier string; for example, into ("MacBookPro", 6, 1).
// If any error occurs, none of the input pointers are touched.
bool ParseModelIdentifier(const std::string& ident,
- std::string* type,
- int32_t* major,
- int32_t* minor);
+ std::string* type,
+ int32_t* major,
+ int32_t* minor);
} // namespace mac
} // namespace base
diff --git a/base/mac/mac_util.mm b/base/mac/mac_util.mm
index a8308be..bb8797d 100644
--- a/base/mac/mac_util.mm
+++ b/base/mac/mac_util.mm
@@ -32,7 +32,7 @@
// The current count of outstanding requests for full screen mode from browser
// windows, plugins, etc.
-int g_full_screen_requests[kNumFullScreenModes] = { 0 };
+int g_full_screen_requests[kNumFullScreenModes] = {0};
// Sets the appropriate application presentation option based on the current
// full screen requests. Since only one presentation option can be active at a
@@ -82,8 +82,8 @@
// representing the current application. If such an item is found, returns a
// retained reference to it. Caller is responsible for releasing the reference.
LSSharedFileListItemRef GetLoginItemForApp() {
- ScopedCFTypeRef<LSSharedFileListRef> login_items(LSSharedFileListCreate(
- NULL, kLSSharedFileListSessionLoginItems, NULL));
+ ScopedCFTypeRef<LSSharedFileListRef> login_items(
+ LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL));
if (!login_items.get()) {
DLOG(ERROR) << "Couldn't get a Login Items list.";
@@ -95,7 +95,7 @@
NSURL* url = [NSURL fileURLWithPath:[base::mac::MainBundle() bundlePath]];
- for(NSUInteger i = 0; i < [login_items_array count]; ++i) {
+ for (NSUInteger i = 0; i < [login_items_array count]; ++i) {
LSSharedFileListItemRef item =
reinterpret_cast<LSSharedFileListItemRef>(login_items_array[i]);
CFURLRef item_url_ref = NULL;
@@ -117,8 +117,9 @@
}
bool IsHiddenLoginItem(LSSharedFileListItemRef item) {
- ScopedCFTypeRef<CFBooleanRef> hidden(reinterpret_cast<CFBooleanRef>(
- LSSharedFileListItemCopyProperty(item,
+ ScopedCFTypeRef<CFBooleanRef> hidden(
+ reinterpret_cast<CFBooleanRef>(LSSharedFileListItemCopyProperty(
+ item,
reinterpret_cast<CFStringRef>(kLSSharedFileListLoginItemHidden))));
return hidden && hidden == kCFBooleanTrue;
@@ -130,8 +131,8 @@
// Leaked. That's OK, it's scoped to the lifetime of the application.
static CGColorSpaceRef g_color_space_generic_rgb(
CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB));
- DLOG_IF(ERROR, !g_color_space_generic_rgb) <<
- "Couldn't get the generic RGB color space";
+ DLOG_IF(ERROR, !g_color_space_generic_rgb)
+ << "Couldn't get the generic RGB color space";
return g_color_space_generic_rgb;
}
@@ -154,8 +155,8 @@
g_system_color_space = CGColorSpaceCreateDeviceRGB();
if (g_system_color_space) {
- DLOG(WARNING) <<
- "Couldn't get the main display's color space, using generic";
+ DLOG(WARNING)
+ << "Couldn't get the main display's color space, using generic";
} else {
DLOG(ERROR) << "Couldn't get any color space";
}
@@ -247,8 +248,8 @@
return; // Already is a login item with required hide flag.
}
- ScopedCFTypeRef<LSSharedFileListRef> login_items(LSSharedFileListCreate(
- NULL, kLSSharedFileListSessionLoginItems, NULL));
+ ScopedCFTypeRef<LSSharedFileListRef> login_items(
+ LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL));
if (!login_items.get()) {
DLOG(ERROR) << "Couldn't get a Login Items list.";
@@ -263,10 +264,9 @@
NSURL* url = [NSURL fileURLWithPath:[base::mac::MainBundle() bundlePath]];
BOOL hide = hide_on_startup ? YES : NO;
- NSDictionary* properties =
- [NSDictionary
- dictionaryWithObject:[NSNumber numberWithBool:hide]
- forKey:(NSString*)kLSSharedFileListLoginItemHidden];
+ NSDictionary* properties = [NSDictionary
+ dictionaryWithObject:[NSNumber numberWithBool:hide]
+ forKey:(NSString*)kLSSharedFileListLoginItemHidden];
ScopedCFTypeRef<LSSharedFileListItemRef> new_item;
new_item.reset(LSSharedFileListInsertItemURL(
@@ -284,8 +284,8 @@
if (!item.get())
return;
- ScopedCFTypeRef<LSSharedFileListRef> login_items(LSSharedFileListCreate(
- NULL, kLSSharedFileListSessionLoginItems, NULL));
+ ScopedCFTypeRef<LSSharedFileListRef> login_items(
+ LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL));
if (!login_items.get()) {
DLOG(ERROR) << "Couldn't get a Login Items list.";
@@ -296,7 +296,7 @@
}
bool WasLaunchedAsLoginOrResumeItem() {
- ProcessSerialNumber psn = { 0, kCurrentProcess };
+ ProcessSerialNumber psn = {0, kCurrentProcess};
ProcessInfoRec info = {};
info.processInfoLength = sizeof(info);
@@ -393,9 +393,9 @@
int darwin_major_version = 0;
char* dot = strchr(uname_info.release, '.');
if (dot) {
- if (!base::StringToInt(base::StringPiece(uname_info.release,
- dot - uname_info.release),
- &darwin_major_version)) {
+ if (!base::StringToInt(
+ base::StringPiece(uname_info.release, dot - uname_info.release),
+ &darwin_major_version)) {
dot = NULL;
}
}
@@ -440,16 +440,12 @@
std::string GetModelIdentifier() {
std::string return_string;
- ScopedIOObject<io_service_t> platform_expert(
- IOServiceGetMatchingService(kIOMasterPortDefault,
- IOServiceMatching("IOPlatformExpertDevice")));
+ ScopedIOObject<io_service_t> platform_expert(IOServiceGetMatchingService(
+ kIOMasterPortDefault, IOServiceMatching("IOPlatformExpertDevice")));
if (platform_expert) {
ScopedCFTypeRef<CFDataRef> model_data(
static_cast<CFDataRef>(IORegistryEntryCreateCFProperty(
- platform_expert,
- CFSTR("model"),
- kCFAllocatorDefault,
- 0)));
+ platform_expert, CFSTR("model"), kCFAllocatorDefault, 0)));
if (model_data) {
return_string =
reinterpret_cast<const char*>(CFDataGetBytePtr(model_data));
@@ -470,10 +466,9 @@
return false;
int32_t major_tmp, minor_tmp;
std::string::const_iterator begin = ident.begin();
- if (!StringToInt(
- StringPiece(begin + number_loc, begin + comma_loc), &major_tmp) ||
- !StringToInt(
- StringPiece(begin + comma_loc + 1, ident.end()), &minor_tmp))
+ if (!StringToInt(StringPiece(begin + number_loc, begin + comma_loc),
+ &major_tmp) ||
+ !StringToInt(StringPiece(begin + comma_loc + 1, ident.end()), &minor_tmp))
return false;
*type = ident.substr(0, number_loc);
*major = major_tmp;
diff --git a/base/mac/mach_logging.cc b/base/mac/mach_logging.cc
index fbd0134..b708ded 100644
--- a/base/mac/mach_logging.cc
+++ b/base/mac/mach_logging.cc
@@ -34,13 +34,10 @@
int line,
LogSeverity severity,
mach_error_t mach_err)
- : LogMessage(file_path, line, severity),
- mach_err_(mach_err) {
-}
+ : LogMessage(file_path, line, severity), mach_err_(mach_err) {}
MachLogMessage::~MachLogMessage() {
- stream() << ": "
- << mach_error_string(mach_err_)
+ stream() << ": " << mach_error_string(mach_err_)
<< FormatMachErrorNumber(mach_err_);
}
@@ -50,13 +47,10 @@
int line,
LogSeverity severity,
kern_return_t bootstrap_err)
- : LogMessage(file_path, line, severity),
- bootstrap_err_(bootstrap_err) {
-}
+ : LogMessage(file_path, line, severity), bootstrap_err_(bootstrap_err) {}
BootstrapLogMessage::~BootstrapLogMessage() {
- stream() << ": "
- << bootstrap_strerror(bootstrap_err_);
+ stream() << ": " << bootstrap_strerror(bootstrap_err_);
switch (bootstrap_err_) {
case BOOTSTRAP_SUCCESS:
diff --git a/base/mac/mach_logging.h b/base/mac/mach_logging.h
index e32e1db..1f20b85 100644
--- a/base/mac/mach_logging.h
+++ b/base/mac/mach_logging.h
@@ -49,23 +49,23 @@
} // namespace logging
#define MACH_LOG_STREAM(severity, mach_err) \
- COMPACT_GOOGLE_LOG_EX_ ## severity(MachLogMessage, mach_err).stream()
+ COMPACT_GOOGLE_LOG_EX_##severity(MachLogMessage, mach_err).stream()
#define MACH_LOG(severity, mach_err) \
- LAZY_STREAM(MACH_LOG_STREAM(severity, mach_err), LOG_IS_ON(severity))
+ LAZY_STREAM(MACH_LOG_STREAM(severity, mach_err), LOG_IS_ON(severity))
#define MACH_LOG_IF(severity, condition, mach_err) \
- LAZY_STREAM(MACH_LOG_STREAM(severity, mach_err), \
- LOG_IS_ON(severity) && (condition))
+ LAZY_STREAM(MACH_LOG_STREAM(severity, mach_err), \
+ LOG_IS_ON(severity) && (condition))
-#define MACH_CHECK(condition, mach_err) \
- LAZY_STREAM(MACH_LOG_STREAM(FATAL, mach_err), !(condition)) \
- << "Check failed: " # condition << ". "
+#define MACH_CHECK(condition, mach_err) \
+ LAZY_STREAM(MACH_LOG_STREAM(FATAL, mach_err), !(condition)) \
+ << "Check failed: " #condition << ". "
#define MACH_DLOG(severity, mach_err) \
- LAZY_STREAM(MACH_LOG_STREAM(severity, mach_err), DLOG_IS_ON(severity))
+ LAZY_STREAM(MACH_LOG_STREAM(severity, mach_err), DLOG_IS_ON(severity))
#define MACH_DLOG_IF(severity, condition, mach_err) \
- LAZY_STREAM(MACH_LOG_STREAM(severity, mach_err), \
- DLOG_IS_ON(severity) && (condition))
+ LAZY_STREAM(MACH_LOG_STREAM(severity, mach_err), \
+ DLOG_IS_ON(severity) && (condition))
#define MACH_DCHECK(condition, mach_err) \
LAZY_STREAM(MACH_LOG_STREAM(FATAL, mach_err), \
@@ -93,25 +93,24 @@
} // namespace logging
#define BOOTSTRAP_LOG_STREAM(severity, bootstrap_err) \
- COMPACT_GOOGLE_LOG_EX_ ## severity(BootstrapLogMessage, \
- bootstrap_err).stream()
-#define BOOTSTRAP_LOG(severity, bootstrap_err) \
- LAZY_STREAM(BOOTSTRAP_LOG_STREAM(severity, \
- bootstrap_err), LOG_IS_ON(severity))
+ COMPACT_GOOGLE_LOG_EX_##severity(BootstrapLogMessage, bootstrap_err).stream()
+#define BOOTSTRAP_LOG(severity, bootstrap_err) \
+ LAZY_STREAM(BOOTSTRAP_LOG_STREAM(severity, bootstrap_err), \
+ LOG_IS_ON(severity))
#define BOOTSTRAP_LOG_IF(severity, condition, bootstrap_err) \
- LAZY_STREAM(BOOTSTRAP_LOG_STREAM(severity, bootstrap_err), \
- LOG_IS_ON(severity) && (condition))
+ LAZY_STREAM(BOOTSTRAP_LOG_STREAM(severity, bootstrap_err), \
+ LOG_IS_ON(severity) && (condition))
-#define BOOTSTRAP_CHECK(condition, bootstrap_err) \
- LAZY_STREAM(BOOTSTRAP_LOG_STREAM(FATAL, bootstrap_err), !(condition)) \
- << "Check failed: " # condition << ". "
+#define BOOTSTRAP_CHECK(condition, bootstrap_err) \
+ LAZY_STREAM(BOOTSTRAP_LOG_STREAM(FATAL, bootstrap_err), !(condition)) \
+ << "Check failed: " #condition << ". "
-#define BOOTSTRAP_DLOG(severity, bootstrap_err) \
- LAZY_STREAM(BOOTSTRAP_LOG_STREAM(severity, bootstrap_err), \
- DLOG_IS_ON(severity))
+#define BOOTSTRAP_DLOG(severity, bootstrap_err) \
+ LAZY_STREAM(BOOTSTRAP_LOG_STREAM(severity, bootstrap_err), \
+ DLOG_IS_ON(severity))
#define BOOTSTRAP_DLOG_IF(severity, condition, bootstrap_err) \
- LAZY_STREAM(BOOTSTRAP_LOG_STREAM(severity, bootstrap_err), \
- DLOG_IS_ON(severity) && (condition))
+ LAZY_STREAM(BOOTSTRAP_LOG_STREAM(severity, bootstrap_err), \
+ DLOG_IS_ON(severity) && (condition))
#define BOOTSTRAP_DCHECK(condition, bootstrap_err) \
LAZY_STREAM(BOOTSTRAP_LOG_STREAM(FATAL, bootstrap_err), \
diff --git a/base/mac/scoped_cftyperef.h b/base/mac/scoped_cftyperef.h
index ccbc5cf..a602fd9 100644
--- a/base/mac/scoped_cftyperef.h
+++ b/base/mac/scoped_cftyperef.h
@@ -27,21 +27,19 @@
namespace internal {
-template<typename CFT>
+template <typename CFT>
struct ScopedCFTypeRefTraits {
static CFT InvalidValue() { return nullptr; }
static CFT Retain(CFT object) {
CFRetain(object);
return object;
}
- static void Release(CFT object) {
- CFRelease(object);
- }
+ static void Release(CFT object) { CFRelease(object); }
};
} // namespace internal
-template<typename CFT>
+template <typename CFT>
using ScopedCFTypeRef =
ScopedTypeRef<CFT, internal::ScopedCFTypeRefTraits<CFT>>;
diff --git a/base/mac/scoped_dispatch_object.h b/base/mac/scoped_dispatch_object.h
index cd2daf2..43d057b 100644
--- a/base/mac/scoped_dispatch_object.h
+++ b/base/mac/scoped_dispatch_object.h
@@ -20,12 +20,10 @@
dispatch_retain(object);
return object;
}
- static void Release(T object) {
- dispatch_release(object);
- }
+ static void Release(T object) { dispatch_release(object); }
};
-} // namepsace internal
+} // namespace internal
template <typename T>
using ScopedDispatchObject =
diff --git a/base/mac/scoped_ioobject.h b/base/mac/scoped_ioobject.h
index c948cb5..d656175 100644
--- a/base/mac/scoped_ioobject.h
+++ b/base/mac/scoped_ioobject.h
@@ -24,7 +24,7 @@
static void Release(IOT iot) { IOObjectRelease(iot); }
};
-} // namespce internal
+} // namespace internal
// Just like ScopedCFTypeRef but for io_object_t and subclasses.
template <typename IOT>
diff --git a/base/mac/scoped_mach_port.h b/base/mac/scoped_mach_port.h
index 9b4470d..64d6765 100644
--- a/base/mac/scoped_mach_port.h
+++ b/base/mac/scoped_mach_port.h
@@ -15,25 +15,19 @@
namespace internal {
struct SendRightTraits {
- static mach_port_t InvalidValue() {
- return MACH_PORT_NULL;
- }
+ static mach_port_t InvalidValue() { return MACH_PORT_NULL; }
static void Free(mach_port_t port);
};
struct ReceiveRightTraits {
- static mach_port_t InvalidValue() {
- return MACH_PORT_NULL;
- }
+ static mach_port_t InvalidValue() { return MACH_PORT_NULL; }
static void Free(mach_port_t port);
};
struct PortSetTraits {
- static mach_port_t InvalidValue() {
- return MACH_PORT_NULL;
- }
+ static mach_port_t InvalidValue() { return MACH_PORT_NULL; }
static void Free(mach_port_t port);
};
diff --git a/base/mac/scoped_nsautorelease_pool.h b/base/mac/scoped_nsautorelease_pool.h
index 017f1c0..fd4ae66 100644
--- a/base/mac/scoped_nsautorelease_pool.h
+++ b/base/mac/scoped_nsautorelease_pool.h
@@ -9,7 +9,7 @@
#if defined(__OBJC__)
@class NSAutoreleasePool;
-#else // __OBJC__
+#else // __OBJC__
class NSAutoreleasePool;
#endif // __OBJC__
@@ -31,6 +31,7 @@
// Only use then when you're certain the items currently in the pool are
// no longer needed.
void Recycle();
+
private:
NSAutoreleasePool* autorelease_pool_;
diff --git a/base/mac/scoped_nsobject.h b/base/mac/scoped_nsobject.h
index 45ab325..a5da218 100644
--- a/base/mac/scoped_nsobject.h
+++ b/base/mac/scoped_nsobject.h
@@ -191,7 +191,7 @@
};
// Specialization to make scoped_nsobject<id> work.
-template<>
+template <>
class scoped_nsobject<id> : public scoped_nsprotocol<id> {
public:
using Traits = typename scoped_nsprotocol<id>::Traits;
diff --git a/base/mac/scoped_typeref.h b/base/mac/scoped_typeref.h
index dd9841d..659ee34 100644
--- a/base/mac/scoped_typeref.h
+++ b/base/mac/scoped_typeref.h
@@ -45,10 +45,10 @@
// with |ASSUME| for the former and |RETAIN| for the latter. The default policy
// is to |ASSUME|.
-template<typename T>
+template <typename T>
struct ScopedTypeRefTraits;
-template<typename T, typename Traits = ScopedTypeRefTraits<T>>
+template <typename T, typename Traits = ScopedTypeRefTraits<T>>
class ScopedTypeRef {
public:
typedef T element_type;
@@ -61,8 +61,7 @@
object_ = Traits::Retain(object_);
}
- ScopedTypeRef(const ScopedTypeRef<T, Traits>& that)
- : object_(that.object_) {
+ ScopedTypeRef(const ScopedTypeRef<T, Traits>& that) : object_(that.object_) {
if (object_)
object_ = Traits::Retain(object_);
}
diff --git a/base/macros.h b/base/macros.h
index 3064a1b..f59fa6c 100644
--- a/base/macros.h
+++ b/base/macros.h
@@ -23,8 +23,7 @@
#endif
// Put this in the declarations for a class to be uncopyable.
-#define DISALLOW_COPY(TypeName) \
- TypeName(const TypeName&) = delete
+#define DISALLOW_COPY(TypeName) TypeName(const TypeName&) = delete
// Put this in the declarations for a class to be unassignable.
#define DISALLOW_ASSIGN(TypeName) TypeName& operator=(const TypeName&) = delete
@@ -53,7 +52,8 @@
//
// DEPRECATED, please use base::size(array) instead.
// TODO(https://crbug.com/837308): Replace existing arraysize usages.
-template <typename T, size_t N> char (&ArraySizeHelper(T (&array)[N]))[N];
+template <typename T, size_t N>
+char (&ArraySizeHelper(T (&array)[N]))[N];
#define arraysize(array) (sizeof(ArraySizeHelper(array)))
// Used to explicitly mark the return value of a function as unused. If you are
@@ -64,9 +64,8 @@
// if (TakeOwnership(my_var.get()) == SUCCESS)
// ignore_result(my_var.release());
//
-template<typename T>
-inline void ignore_result(const T&) {
-}
+template <typename T>
+inline void ignore_result(const T&) {}
namespace base {
diff --git a/base/md5.cc b/base/md5.cc
index 72c774d..c66f7b2 100644
--- a/base/md5.cc
+++ b/base/md5.cc
@@ -38,9 +38,9 @@
*/
void byteReverse(uint8_t* buf, unsigned longs) {
do {
- uint32_t temp = static_cast<uint32_t>(
- static_cast<unsigned>(buf[3]) << 8 |
- buf[2]) << 16 |
+ uint32_t temp =
+ static_cast<uint32_t>(static_cast<unsigned>(buf[3]) << 8 | buf[2])
+ << 16 |
(static_cast<unsigned>(buf[1]) << 8 | buf[0]);
*reinterpret_cast<uint32_t*>(buf) = temp;
buf += 4;
diff --git a/base/md5.h b/base/md5.h
index e6345b1..16a0a6f 100644
--- a/base/md5.h
+++ b/base/md5.h
@@ -59,8 +59,7 @@
// MD5IntermediateFinal() generates a digest without finalizing the MD5
// operation. Can be used to generate digests for the input seen thus far,
// without affecting the digest generated for the entire input.
-void MD5IntermediateFinal(MD5Digest* digest,
- const MD5Context* context);
+void MD5IntermediateFinal(MD5Digest* digest, const MD5Context* context);
// Converts a digest into human-readable hexadecimal.
std::string MD5DigestToBase16(const MD5Digest& digest);
diff --git a/base/memory/free_deleter.h b/base/memory/free_deleter.h
index 5604118..e12795c 100644
--- a/base/memory/free_deleter.h
+++ b/base/memory/free_deleter.h
@@ -15,9 +15,7 @@
// std::unique_ptr<int, base::FreeDeleter> foo_ptr(
// static_cast<int*>(malloc(sizeof(int))));
struct FreeDeleter {
- inline void operator()(void* ptr) const {
- free(ptr);
- }
+ inline void operator()(void* ptr) const { free(ptr); }
};
} // namespace base
diff --git a/base/memory/ref_counted.h b/base/memory/ref_counted.h
index 9447d51..a897171 100644
--- a/base/memory/ref_counted.h
+++ b/base/memory/ref_counted.h
@@ -24,18 +24,13 @@
bool HasOneRef() const { return ref_count_ == 1; }
protected:
- explicit RefCountedBase(StartRefCountFromZeroTag) {
- }
+ explicit RefCountedBase(StartRefCountFromZeroTag) {}
- explicit RefCountedBase(StartRefCountFromOneTag) : ref_count_(1) {
- }
+ explicit RefCountedBase(StartRefCountFromOneTag) : ref_count_(1) {}
- ~RefCountedBase() {
- }
+ ~RefCountedBase() {}
- void AddRef() const {
- AddRefImpl();
- }
+ void AddRef() const { AddRefImpl(); }
// Returns true if the object should self-delete.
bool Release() const {
@@ -62,16 +57,13 @@
// the sending thread), but will trap if the sending thread holds onto a
// reference, or if the object is accessed from multiple threads
// simultaneously.
- bool IsOnValidSequence() const {
- return true;
- }
+ bool IsOnValidSequence() const { return true; }
private:
template <typename U>
friend scoped_refptr<U> base::AdoptRef(U*);
- void Adopted() const {
- }
+ void Adopted() const {}
#if defined(ARCH_CPU_64_BIT)
void AddRefImpl() const;
@@ -91,8 +83,7 @@
protected:
explicit constexpr RefCountedThreadSafeBase(StartRefCountFromZeroTag) {}
explicit constexpr RefCountedThreadSafeBase(StartRefCountFromOneTag)
- : ref_count_(1) {
- }
+ : ref_count_(1) {}
~RefCountedThreadSafeBase() = default;
@@ -113,12 +104,9 @@
template <typename U>
friend scoped_refptr<U> base::AdoptRef(U*);
- void Adopted() const {
- }
+ void Adopted() const {}
- ALWAYS_INLINE void AddRefImpl() const {
- ref_count_.Increment();
- }
+ ALWAYS_INLINE void AddRefImpl() const { ref_count_.Increment(); }
ALWAYS_INLINE bool ReleaseImpl() const {
if (!ref_count_.Decrement()) {
@@ -216,9 +204,7 @@
RefCounted() : subtle::RefCountedBase(T::kRefCountPreference) {}
- void AddRef() const {
- subtle::RefCountedBase::AddRef();
- }
+ void AddRef() const { subtle::RefCountedBase::AddRef(); }
void Release() const {
if (subtle::RefCountedBase::Release()) {
@@ -245,18 +231,19 @@
};
// Forward declaration.
-template <class T, typename Traits> class RefCountedThreadSafe;
+template <class T, typename Traits>
+class RefCountedThreadSafe;
// Default traits for RefCountedThreadSafe<T>. Deletes the object when its ref
// count reaches 0. Overload to delete it on a different thread etc.
-template<typename T>
+template <typename T>
struct DefaultRefCountedThreadSafeTraits {
static void Destruct(const T* x) {
// Delete through RefCountedThreadSafe to make child classes only need to be
// friend with RefCountedThreadSafe instead of this struct, which is an
// implementation detail.
- RefCountedThreadSafe<T,
- DefaultRefCountedThreadSafeTraits>::DeleteInternal(x);
+ RefCountedThreadSafe<T, DefaultRefCountedThreadSafeTraits>::DeleteInternal(
+ x);
}
};
@@ -275,7 +262,7 @@
//
// We can use REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() with RefCountedThreadSafe
// too. See the comment above the RefCounted definition for details.
-template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T> >
+template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T>>
class RefCountedThreadSafe : public subtle::RefCountedThreadSafeBase {
public:
static constexpr subtle::StartRefCountFromZeroTag kRefCountPreference =
@@ -284,9 +271,7 @@
explicit RefCountedThreadSafe()
: subtle::RefCountedThreadSafeBase(T::kRefCountPreference) {}
- void AddRef() const {
- subtle::RefCountedThreadSafeBase::AddRef();
- }
+ void AddRef() const { subtle::RefCountedThreadSafeBase::AddRef(); }
void Release() const {
if (subtle::RefCountedThreadSafeBase::Release()) {
@@ -312,9 +297,9 @@
// A thread-safe wrapper for some piece of data so we can place other
// things in scoped_refptrs<>.
//
-template<typename T>
+template <typename T>
class RefCountedData
- : public base::RefCountedThreadSafe< base::RefCountedData<T> > {
+ : public base::RefCountedThreadSafe<base::RefCountedData<T>> {
public:
RefCountedData() : data() {}
RefCountedData(const T& in_value) : data(in_value) {}
@@ -323,7 +308,7 @@
T data;
private:
- friend class base::RefCountedThreadSafe<base::RefCountedData<T> >;
+ friend class base::RefCountedThreadSafe<base::RefCountedData<T>>;
~RefCountedData() = default;
};
diff --git a/base/memory/weak_ptr.cc b/base/memory/weak_ptr.cc
index 1186829..4abeb7f 100644
--- a/base/memory/weak_ptr.cc
+++ b/base/memory/weak_ptr.cc
@@ -7,8 +7,7 @@
namespace base {
namespace internal {
-WeakReference::Flag::Flag() : is_valid_(true) {
-}
+WeakReference::Flag::Flag() : is_valid_(true) {}
void WeakReference::Flag::Invalidate() {
is_valid_ = false;
diff --git a/base/memory/weak_ptr.h b/base/memory/weak_ptr.h
index 2a42692..3b2a0af 100644
--- a/base/memory/weak_ptr.h
+++ b/base/memory/weak_ptr.h
@@ -79,8 +79,10 @@
namespace base {
-template <typename T> class SupportsWeakPtr;
-template <typename T> class WeakPtr;
+template <typename T>
+class SupportsWeakPtr;
+template <typename T>
+class WeakPtr;
namespace internal {
// These classes are part of the WeakPtr implementation.
@@ -175,7 +177,7 @@
// function that makes calling this easier.
//
// Precondition: t != nullptr
- template<typename Derived>
+ template <typename Derived>
static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
static_assert(
std::is_base_of<internal::SupportsWeakPtrBase, Derived>::value,
@@ -197,7 +199,8 @@
} // namespace internal
-template <typename T> class WeakPtrFactory;
+template <typename T>
+class WeakPtrFactory;
// The WeakPtr class holds a weak reference to |T*|.
//
@@ -254,7 +257,8 @@
private:
friend class internal::SupportsWeakPtrBase;
- template <typename U> friend class WeakPtr;
+ template <typename U>
+ friend class WeakPtr;
friend class SupportsWeakPtr<T>;
friend class WeakPtrFactory<T>;
diff --git a/base/numerics/safe_conversions_impl.h b/base/numerics/safe_conversions_impl.h
index 2516204..3355b34 100644
--- a/base/numerics/safe_conversions_impl.h
+++ b/base/numerics/safe_conversions_impl.h
@@ -691,9 +691,8 @@
const RangeCheck l_range,
const RangeCheck r_range) {
return l_range.IsUnderflow() || r_range.IsOverflow() ||
- (l_range == r_range &&
- static_cast<decltype(lhs + rhs)>(lhs) <
- static_cast<decltype(lhs + rhs)>(rhs));
+ (l_range == r_range && static_cast<decltype(lhs + rhs)>(lhs) <
+ static_cast<decltype(lhs + rhs)>(rhs));
}
template <typename L, typename R>
@@ -712,9 +711,8 @@
const RangeCheck l_range,
const RangeCheck r_range) {
return l_range.IsUnderflow() || r_range.IsOverflow() ||
- (l_range == r_range &&
- static_cast<decltype(lhs + rhs)>(lhs) <=
- static_cast<decltype(lhs + rhs)>(rhs));
+ (l_range == r_range && static_cast<decltype(lhs + rhs)>(lhs) <=
+ static_cast<decltype(lhs + rhs)>(rhs));
}
template <typename L, typename R>
@@ -733,9 +731,8 @@
const RangeCheck l_range,
const RangeCheck r_range) {
return l_range.IsOverflow() || r_range.IsUnderflow() ||
- (l_range == r_range &&
- static_cast<decltype(lhs + rhs)>(lhs) >
- static_cast<decltype(lhs + rhs)>(rhs));
+ (l_range == r_range && static_cast<decltype(lhs + rhs)>(lhs) >
+ static_cast<decltype(lhs + rhs)>(rhs));
}
template <typename L, typename R>
@@ -754,9 +751,8 @@
const RangeCheck l_range,
const RangeCheck r_range) {
return l_range.IsOverflow() || r_range.IsUnderflow() ||
- (l_range == r_range &&
- static_cast<decltype(lhs + rhs)>(lhs) >=
- static_cast<decltype(lhs + rhs)>(rhs));
+ (l_range == r_range && static_cast<decltype(lhs + rhs)>(lhs) >=
+ static_cast<decltype(lhs + rhs)>(rhs));
}
template <typename L, typename R>
diff --git a/base/optional.h b/base/optional.h
index c1d11ca..14aa4be 100644
--- a/base/optional.h
+++ b/base/optional.h
@@ -629,7 +629,7 @@
}
template <class U>
- constexpr T value_or(U&& default_value) const& {
+ constexpr T value_or(U&& default_value) const & {
// TODO(mlamouri): add the following assert when possible:
// static_assert(std::is_copy_constructible<T>::value,
// "T must be copy constructible");
diff --git a/base/posix/eintr_wrapper.h b/base/posix/eintr_wrapper.h
index c3565da..5c24e03 100644
--- a/base/posix/eintr_wrapper.h
+++ b/base/posix/eintr_wrapper.h
@@ -25,38 +25,41 @@
#if defined(NDEBUG)
-#define HANDLE_EINTR(x) ({ \
- decltype(x) eintr_wrapper_result; \
- do { \
- eintr_wrapper_result = (x); \
- } while (eintr_wrapper_result == -1 && errno == EINTR); \
- eintr_wrapper_result; \
-})
+#define HANDLE_EINTR(x) \
+ ({ \
+ decltype(x) eintr_wrapper_result; \
+ do { \
+ eintr_wrapper_result = (x); \
+ } while (eintr_wrapper_result == -1 && errno == EINTR); \
+ eintr_wrapper_result; \
+ })
#else
-#define HANDLE_EINTR(x) ({ \
- int eintr_wrapper_counter = 0; \
- decltype(x) eintr_wrapper_result; \
- do { \
- eintr_wrapper_result = (x); \
- } while (eintr_wrapper_result == -1 && errno == EINTR && \
- eintr_wrapper_counter++ < 100); \
- eintr_wrapper_result; \
-})
+#define HANDLE_EINTR(x) \
+ ({ \
+ int eintr_wrapper_counter = 0; \
+ decltype(x) eintr_wrapper_result; \
+ do { \
+ eintr_wrapper_result = (x); \
+ } while (eintr_wrapper_result == -1 && errno == EINTR && \
+ eintr_wrapper_counter++ < 100); \
+ eintr_wrapper_result; \
+ })
#endif // NDEBUG
-#define IGNORE_EINTR(x) ({ \
- decltype(x) eintr_wrapper_result; \
- do { \
- eintr_wrapper_result = (x); \
- if (eintr_wrapper_result == -1 && errno == EINTR) { \
- eintr_wrapper_result = 0; \
- } \
- } while (0); \
- eintr_wrapper_result; \
-})
+#define IGNORE_EINTR(x) \
+ ({ \
+ decltype(x) eintr_wrapper_result; \
+ do { \
+ eintr_wrapper_result = (x); \
+ if (eintr_wrapper_result == -1 && errno == EINTR) { \
+ eintr_wrapper_result = 0; \
+ } \
+ } while (0); \
+ eintr_wrapper_result; \
+ })
#else // !OS_POSIX || OS_FUCHSIA
diff --git a/base/posix/file_descriptor_shuffle.cc b/base/posix/file_descriptor_shuffle.cc
index d2fd39a..f628bec 100644
--- a/base/posix/file_descriptor_shuffle.cc
+++ b/base/posix/file_descriptor_shuffle.cc
@@ -4,17 +4,17 @@
#include "base/posix/file_descriptor_shuffle.h"
-#include <unistd.h>
#include <stddef.h>
+#include <unistd.h>
#include <ostream>
-#include "base/posix/eintr_wrapper.h"
#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
namespace base {
-bool PerformInjectiveMultimapDestructive(
- InjectiveMultimap* m, InjectionDelegate* delegate) {
+bool PerformInjectiveMultimapDestructive(InjectiveMultimap* m,
+ InjectionDelegate* delegate) {
static const size_t kMaxExtraFDs = 16;
int extra_fds[kMaxExtraFDs];
unsigned next_extra_fd = 0;
@@ -29,8 +29,8 @@
// We DCHECK the injectiveness of the mapping.
for (size_t j_index = i_index + 1; j_index < m->size(); ++j_index) {
InjectiveMultimap::value_type* j = &(*m)[j_index];
- DCHECK(i->dest != j->dest) << "Both fd " << i->source
- << " and " << j->source << " map to " << i->dest;
+ DCHECK(i->dest != j->dest) << "Both fd " << i->source << " and "
+ << j->source << " map to " << i->dest;
}
const bool is_identity = i->source == i->dest;
@@ -44,8 +44,9 @@
if (next_extra_fd < kMaxExtraFDs) {
extra_fds[next_extra_fd++] = temp_fd;
} else {
- RAW_LOG(ERROR, "PerformInjectiveMultimapDestructive overflowed "
- "extra_fds. Leaking file descriptors!");
+ RAW_LOG(ERROR,
+ "PerformInjectiveMultimapDestructive overflowed "
+ "extra_fds. Leaking file descriptors!");
}
}
diff --git a/base/posix/file_descriptor_shuffle.h b/base/posix/file_descriptor_shuffle.h
index f2e8877..6843498 100644
--- a/base/posix/file_descriptor_shuffle.h
+++ b/base/posix/file_descriptor_shuffle.h
@@ -55,10 +55,7 @@
// A single arc of the directed graph which describes an injective multimapping.
struct InjectionArc {
InjectionArc(int in_source, int in_dest, bool in_close)
- : source(in_source),
- dest(in_dest),
- close(in_close) {
- }
+ : source(in_source), dest(in_dest), close(in_close) {}
int source;
int dest;
@@ -69,11 +66,10 @@
typedef std::vector<InjectionArc> InjectiveMultimap;
bool PerformInjectiveMultimap(const InjectiveMultimap& map,
- InjectionDelegate* delegate);
+ InjectionDelegate* delegate);
-bool PerformInjectiveMultimapDestructive(
- InjectiveMultimap* map,
- InjectionDelegate* delegate);
+bool PerformInjectiveMultimapDestructive(InjectiveMultimap* map,
+ InjectionDelegate* delegate);
// This function will not call malloc but will mutate |map|
static inline bool ShuffleFileDescriptors(InjectiveMultimap* map) {
diff --git a/base/posix/safe_strerror.cc b/base/posix/safe_strerror.cc
index aa18098..3ae684f 100644
--- a/base/posix/safe_strerror.cc
+++ b/base/posix/safe_strerror.cc
@@ -39,13 +39,13 @@
// glibc has two strerror_r functions: a historical GNU-specific one that
// returns type char *, and a POSIX.1-2001 compliant one available since 2.3.4
// that returns int. This wraps the GNU-specific one.
-static void POSSIBLY_UNUSED wrap_posix_strerror_r(
- char *(*strerror_r_ptr)(int, char *, size_t),
- int err,
- char *buf,
- size_t len) {
+static void POSSIBLY_UNUSED
+wrap_posix_strerror_r(char* (*strerror_r_ptr)(int, char*, size_t),
+ int err,
+ char* buf,
+ size_t len) {
// GNU version.
- char *rc = (*strerror_r_ptr)(err, buf, len);
+ char* rc = (*strerror_r_ptr)(err, buf, len);
if (rc != buf) {
// glibc did not use buf and returned a static string instead. Copy it
// into buf.
@@ -62,11 +62,12 @@
// guarantee that they are handled. This is compiled on all POSIX platforms, but
// it will only be used on Linux if the POSIX strerror_r implementation is
// being used (see below).
-static void POSSIBLY_UNUSED wrap_posix_strerror_r(
- int (*strerror_r_ptr)(int, char *, size_t),
- int err,
- char *buf,
- size_t len) {
+static void POSSIBLY_UNUSED wrap_posix_strerror_r(int (*strerror_r_ptr)(int,
+ char*,
+ size_t),
+ int err,
+ char* buf,
+ size_t len) {
int old_errno = errno;
// Have to cast since otherwise we get an error if this is the GNU version
// (but in such a scenario this function is never called). Sadly we can't use
@@ -98,16 +99,13 @@
strerror_error = result;
}
// snprintf truncates and always null-terminates.
- snprintf(buf,
- len,
- "Error %d while retrieving error %d",
- strerror_error,
+ snprintf(buf, len, "Error %d while retrieving error %d", strerror_error,
err);
}
errno = old_errno;
}
-void safe_strerror_r(int err, char *buf, size_t len) {
+void safe_strerror_r(int err, char* buf, size_t len) {
if (buf == nullptr || len <= 0) {
return;
}
diff --git a/base/posix/safe_strerror.h b/base/posix/safe_strerror.h
index 5a2f888..48e9db9 100644
--- a/base/posix/safe_strerror.h
+++ b/base/posix/safe_strerror.h
@@ -9,7 +9,6 @@
#include <string>
-
namespace base {
// BEFORE using anything from this file, first look at PLOG and friends in
@@ -28,7 +27,7 @@
// result is always null-terminated. The value of errno is never changed.
//
// Use this instead of strerror_r().
-void safe_strerror_r(int err, char *buf, size_t len);
+void safe_strerror_r(int err, char* buf, size_t len);
// Calls safe_strerror_r with a buffer of suitable size and returns the result
// in a C++ string.
diff --git a/base/process/internal_linux.cc b/base/process/internal_linux.cc
index 69a1a5b..6c2cafa 100644
--- a/base/process/internal_linux.cc
+++ b/base/process/internal_linux.cc
@@ -89,14 +89,13 @@
// PID.
proc_stats->push_back(stats_data.substr(0, open_parens_idx));
// Process name without parentheses.
- proc_stats->push_back(
- stats_data.substr(open_parens_idx + 1,
- close_parens_idx - (open_parens_idx + 1)));
+ proc_stats->push_back(stats_data.substr(
+ open_parens_idx + 1, close_parens_idx - (open_parens_idx + 1)));
// Split the rest.
- std::vector<std::string> other_stats = SplitString(
- stats_data.substr(close_parens_idx + 2), " ",
- base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+ std::vector<std::string> other_stats =
+ SplitString(stats_data.substr(close_parens_idx + 2), " ",
+ base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
for (size_t i = 0; i < other_stats.size(); ++i)
proc_stats->push_back(other_stats[i]);
return true;
@@ -150,8 +149,7 @@
return ReadStatFileAndGetFieldAsInt64(stat_file, field_num);
}
-size_t ReadProcStatsAndGetFieldAsSizeT(pid_t pid,
- ProcStatsFields field_num) {
+size_t ReadProcStatsAndGetFieldAsSizeT(pid_t pid, ProcStatsFields field_num) {
std::string stats_data;
if (!ReadProcStats(pid, &stats_data))
return 0;
@@ -214,8 +212,8 @@
// It may be the case that this value is always 100.
static const int kHertz = sysconf(_SC_CLK_TCK);
- return TimeDelta::FromMicroseconds(
- Time::kMicrosecondsPerSecond * clock_ticks / kHertz);
+ return TimeDelta::FromMicroseconds(Time::kMicrosecondsPerSecond *
+ clock_ticks / kHertz);
}
} // namespace internal
diff --git a/base/process/internal_linux.h b/base/process/internal_linux.h
index d8904fd..56c08e6 100644
--- a/base/process/internal_linux.h
+++ b/base/process/internal_linux.h
@@ -82,8 +82,7 @@
int64_t ReadProcSelfStatsAndGetFieldAsInt64(ProcStatsFields field_num);
// Same as ReadProcStatsAndGetFieldAsInt64() but for size_t values.
-size_t ReadProcStatsAndGetFieldAsSizeT(pid_t pid,
- ProcStatsFields field_num);
+size_t ReadProcStatsAndGetFieldAsSizeT(pid_t pid, ProcStatsFields field_num);
// Returns the time that the OS started. Clock ticks are relative to this.
Time GetBootTime();
diff --git a/base/process/kill.h b/base/process/kill.h
index 4bed1e5..89ab97b 100644
--- a/base/process/kill.h
+++ b/base/process/kill.h
@@ -46,13 +46,13 @@
// exit code arguments to KillProcess*(), use platform/application
// specific values instead.
enum TerminationStatus {
- TERMINATION_STATUS_NORMAL_TERMINATION, // zero exit status
- TERMINATION_STATUS_ABNORMAL_TERMINATION, // non-zero exit status
- TERMINATION_STATUS_PROCESS_WAS_KILLED, // e.g. SIGKILL or task manager kill
- TERMINATION_STATUS_PROCESS_CRASHED, // e.g. Segmentation fault
- TERMINATION_STATUS_STILL_RUNNING, // child hasn't exited yet
- TERMINATION_STATUS_LAUNCH_FAILED, // child process never launched
- TERMINATION_STATUS_OOM, // Process died due to oom
+ TERMINATION_STATUS_NORMAL_TERMINATION, // zero exit status
+ TERMINATION_STATUS_ABNORMAL_TERMINATION, // non-zero exit status
+ TERMINATION_STATUS_PROCESS_WAS_KILLED, // e.g. SIGKILL or task manager kill
+ TERMINATION_STATUS_PROCESS_CRASHED, // e.g. Segmentation fault
+ TERMINATION_STATUS_STILL_RUNNING, // child hasn't exited yet
+ TERMINATION_STATUS_LAUNCH_FAILED, // child process never launched
+ TERMINATION_STATUS_OOM, // Process died due to oom
TERMINATION_STATUS_MAX_ENUM
};
@@ -62,8 +62,8 @@
// Returns true if all processes were able to be killed off, false if at least
// one couldn't be killed.
bool KillProcesses(const FilePath::StringType& executable_name,
- int exit_code,
- const ProcessFilter* filter);
+ int exit_code,
+ const ProcessFilter* filter);
#if defined(OS_POSIX)
// Attempts to kill the process group identified by |process_group_id|. Returns
@@ -78,8 +78,7 @@
// will only return a useful result the first time it is called after
// the child exits (because it will reap the child and the information
// will no longer be available).
-TerminationStatus GetTerminationStatus(ProcessHandle handle,
- int* exit_code);
+TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code);
#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
// Send a kill signal to the process and then wait for the process to exit
@@ -97,8 +96,8 @@
// GetTerminationStatus as the child will be reaped when WaitForExitCode
// returns, and this information will be lost.
//
-TerminationStatus GetKnownDeadTerminationStatus(
- ProcessHandle handle, int* exit_code);
+TerminationStatus GetKnownDeadTerminationStatus(ProcessHandle handle,
+ int* exit_code);
#if defined(OS_LINUX)
// Spawns a thread to wait asynchronously for the child |process| to exit
@@ -114,10 +113,9 @@
// is non-null, then only processes selected by the filter are waited on.
// Returns after all processes have exited or wait_milliseconds have expired.
// Returns true if all the processes exited, false otherwise.
-bool WaitForProcessesToExit(
- const FilePath::StringType& executable_name,
- base::TimeDelta wait,
- const ProcessFilter* filter);
+bool WaitForProcessesToExit(const FilePath::StringType& executable_name,
+ base::TimeDelta wait,
+ const ProcessFilter* filter);
// Waits a certain amount of time (can be 0) for all the processes with a given
// executable name to exit, then kills off any of them that are still around.
@@ -126,9 +124,9 @@
// any processes needed to be killed, true if they all exited cleanly within
// the wait_milliseconds delay.
bool CleanupProcesses(const FilePath::StringType& executable_name,
- base::TimeDelta wait,
- int exit_code,
- const ProcessFilter* filter);
+ base::TimeDelta wait,
+ int exit_code,
+ const ProcessFilter* filter);
#endif // !defined(OS_FUCHSIA)
} // namespace base
diff --git a/base/process/kill_posix.cc b/base/process/kill_posix.cc
index e6d658c..0e4e84d 100644
--- a/base/process/kill_posix.cc
+++ b/base/process/kill_posix.cc
@@ -28,8 +28,8 @@
DCHECK(exit_code);
int status = 0;
- const pid_t result = HANDLE_EINTR(waitpid(handle, &status,
- can_block ? 0 : WNOHANG));
+ const pid_t result =
+ HANDLE_EINTR(waitpid(handle, &status, can_block ? 0 : WNOHANG));
if (result == -1) {
DPLOG(ERROR) << "waitpid(" << handle << ")";
*exit_code = 0;
diff --git a/base/process/kill_win.cc b/base/process/kill_win.cc
index 7a66442..f598c13 100644
--- a/base/process/kill_win.cc
+++ b/base/process/kill_win.cc
@@ -6,9 +6,9 @@
#include <algorithm>
-#include <windows.h>
#include <io.h>
#include <stdint.h>
+#include <windows.h>
#include "base/logging.h"
#include "base/macros.h"
@@ -92,9 +92,7 @@
DWORD remaining_wait = static_cast<DWORD>(
std::max(static_cast<int64_t>(0),
wait.InMilliseconds() - (GetTickCount() - start_time)));
- HANDLE process = OpenProcess(SYNCHRONIZE,
- FALSE,
- entry->th32ProcessID);
+ HANDLE process = OpenProcess(SYNCHRONIZE, FALSE, entry->th32ProcessID);
DWORD wait_result = WaitForSingleObject(process, remaining_wait);
CloseHandle(process);
result &= (wait_result == WAIT_OBJECT_0);
diff --git a/base/process/memory.cc b/base/process/memory.cc
index 84305e0..2e87fea 100644
--- a/base/process/memory.cc
+++ b/base/process/memory.cc
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "base/logging.h"
#include "base/process/memory.h"
+#include "base/logging.h"
#include "build_config.h"
namespace base {
diff --git a/base/process/memory.h b/base/process/memory.h
index 49dad5d..bbcff68 100644
--- a/base/process/memory.h
+++ b/base/process/memory.h
@@ -71,11 +71,10 @@
// specifically ASan and other sanitizers.
// Return value tells whether the allocation succeeded. If it fails |result| is
// set to NULL, otherwise it holds the memory address.
-WARN_UNUSED_RESULT bool UncheckedMalloc(size_t size,
- void** result);
+WARN_UNUSED_RESULT bool UncheckedMalloc(size_t size, void** result);
WARN_UNUSED_RESULT bool UncheckedCalloc(size_t num_items,
- size_t size,
- void** result);
+ size_t size,
+ void** result);
} // namespace base
diff --git a/base/process/memory_stubs.cc b/base/process/memory_stubs.cc
index 787d9ae..df4657f 100644
--- a/base/process/memory_stubs.cc
+++ b/base/process/memory_stubs.cc
@@ -9,11 +9,9 @@
namespace base {
-void EnableTerminationOnOutOfMemory() {
-}
+void EnableTerminationOnOutOfMemory() {}
-void EnableTerminationOnHeapCorruption() {
-}
+void EnableTerminationOnHeapCorruption() {}
bool AdjustOOMScore(ProcessId process, int score) {
return false;
diff --git a/base/process/memory_win.cc b/base/process/memory_win.cc
index c3fe758..77a2398 100644
--- a/base/process/memory_win.cc
+++ b/base/process/memory_win.cc
@@ -40,7 +40,7 @@
namespace {
#pragma warning(push)
-#pragma warning(disable: 4702) // Unreachable code after the _exit.
+#pragma warning(disable : 4702) // Unreachable code after the _exit.
NOINLINE int OnNoMemory(size_t size) {
// Kill the process. This is important for security since most of code
diff --git a/base/process/process.h b/base/process/process.h
index bef0aef..857bd6d 100644
--- a/base/process/process.h
+++ b/base/process/process.h
@@ -81,10 +81,10 @@
// Close the process handle. This will not terminate the process.
void Close();
- // Returns true if this process is still running. This is only safe on Windows
- // (and maybe Fuchsia?), because the ProcessHandle will keep the zombie
- // process information available until itself has been released. But on Posix,
- // the OS may reuse the ProcessId.
+// Returns true if this process is still running. This is only safe on Windows
+// (and maybe Fuchsia?), because the ProcessHandle will keep the zombie
+// process information available until itself has been released. But on Posix,
+// the OS may reuse the ProcessId.
#if defined(OS_WIN)
bool IsRunning() const {
return !WaitForExitWithTimeout(base::TimeDelta(), nullptr);
diff --git a/base/process/process_handle.h b/base/process/process_handle.h
index f241391..0ec6bf4 100644
--- a/base/process/process_handle.h
+++ b/base/process/process_handle.h
@@ -61,8 +61,7 @@
// WARNING: To avoid inconsistent results from GetUniqueIdForProcess, this
// should only be called very early after process startup - ideally as soon
// after process creation as possible.
-void InitUniqueIdForProcessInPidNamespace(
- ProcessId pid_outside_of_namespace);
+void InitUniqueIdForProcessInPidNamespace(ProcessId pid_outside_of_namespace);
#endif
// Returns the ProcessHandle of the current process.
diff --git a/base/process/process_handle_freebsd.cc b/base/process/process_handle_freebsd.cc
index 192d72b..bbbf660 100644
--- a/base/process/process_handle_freebsd.cc
+++ b/base/process/process_handle_freebsd.cc
@@ -17,7 +17,7 @@
ProcessId GetParentProcessId(ProcessHandle process) {
struct kinfo_proc info;
size_t length;
- int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process };
+ int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, process};
if (sysctl(mib, arraysize(mib), &info, &length, NULL, 0) < 0)
return -1;
@@ -28,7 +28,7 @@
FilePath GetProcessExecutablePath(ProcessHandle process) {
char pathname[PATH_MAX];
size_t length;
- int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, process };
+ int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, process};
length = sizeof(pathname);
diff --git a/base/process/process_handle_mac.cc b/base/process/process_handle_mac.cc
index d9d22f7..6b62406 100644
--- a/base/process/process_handle_mac.cc
+++ b/base/process/process_handle_mac.cc
@@ -16,7 +16,7 @@
ProcessId GetParentProcessId(ProcessHandle process) {
struct kinfo_proc info;
size_t length = sizeof(struct kinfo_proc);
- int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process };
+ int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, process};
if (sysctl(mib, 4, &info, &length, NULL, 0) < 0) {
DPLOG(ERROR) << "sysctl";
return -1;
diff --git a/base/process/process_handle_openbsd.cc b/base/process/process_handle_openbsd.cc
index 045e720..0e85770 100644
--- a/base/process/process_handle_openbsd.cc
+++ b/base/process/process_handle_openbsd.cc
@@ -15,8 +15,9 @@
ProcessId GetParentProcessId(ProcessHandle process) {
struct kinfo_proc info;
size_t length;
- int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process,
- sizeof(struct kinfo_proc), 0 };
+ int mib[] = {
+ CTL_KERN, KERN_PROC, KERN_PROC_PID, process, sizeof(struct kinfo_proc),
+ 0};
if (sysctl(mib, arraysize(mib), NULL, &length, NULL, 0) < 0)
return -1;
@@ -32,8 +33,9 @@
FilePath GetProcessExecutablePath(ProcessHandle process) {
struct kinfo_proc kp;
size_t len;
- int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process,
- sizeof(struct kinfo_proc), 0 };
+ int mib[] = {
+ CTL_KERN, KERN_PROC, KERN_PROC_PID, process, sizeof(struct kinfo_proc),
+ 0};
if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) == -1)
return FilePath();
diff --git a/base/process/process_handle_win.cc b/base/process/process_handle_win.cc
index 67986cd..cf7ab2c 100644
--- a/base/process/process_handle_win.cc
+++ b/base/process/process_handle_win.cc
@@ -5,6 +5,7 @@
#include "base/process/process_handle.h"
#include <windows.h>
+
#include <tlhelp32.h>
#include "base/win/scoped_handle.h"
@@ -28,7 +29,7 @@
ProcessId GetParentProcessId(ProcessHandle process) {
ProcessId child_pid = GetProcId(process);
PROCESSENTRY32 process_entry;
- process_entry.dwSize = sizeof(PROCESSENTRY32);
+ process_entry.dwSize = sizeof(PROCESSENTRY32);
win::ScopedHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0));
if (snapshot.IsValid() && Process32First(snapshot.Get(), &process_entry)) {
diff --git a/base/process/process_info_mac.cc b/base/process/process_info_mac.cc
index 27b9623..3083e53 100644
--- a/base/process/process_info_mac.cc
+++ b/base/process/process_info_mac.cc
@@ -19,7 +19,7 @@
// static
const Time CurrentProcessInfo::CreationTime() {
- int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid() };
+ int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()};
size_t len = 0;
if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) < 0)
return Time();
diff --git a/base/process/process_iterator.cc b/base/process/process_iterator.cc
index 792237b..e56b349 100644
--- a/base/process/process_iterator.cc
+++ b/base/process/process_iterator.cc
@@ -37,9 +37,8 @@
NamedProcessIterator::NamedProcessIterator(
const FilePath::StringType& executable_name,
- const ProcessFilter* filter) : ProcessIterator(filter),
- executable_name_(executable_name) {
-}
+ const ProcessFilter* filter)
+ : ProcessIterator(filter), executable_name_(executable_name) {}
NamedProcessIterator::~NamedProcessIterator() = default;
diff --git a/base/process/process_iterator.h b/base/process/process_iterator.h
index 532104a..b0d96e4 100644
--- a/base/process/process_iterator.h
+++ b/base/process/process_iterator.h
@@ -20,6 +20,7 @@
#if defined(OS_WIN)
#include <windows.h>
+
#include <tlhelp32.h>
#elif defined(OS_MACOSX) || defined(OS_OPENBSD)
#include <sys/sysctl.h>
@@ -141,7 +142,7 @@
// given executable name. If filter is non-null, then only processes selected
// by the filter will be counted.
int GetProcessCount(const FilePath::StringType& executable_name,
- const ProcessFilter* filter);
+ const ProcessFilter* filter);
} // namespace base
diff --git a/base/process/process_iterator_freebsd.cc b/base/process/process_iterator_freebsd.cc
index 4df0d90..a69b2f0 100644
--- a/base/process/process_iterator_freebsd.cc
+++ b/base/process/process_iterator_freebsd.cc
@@ -5,9 +5,9 @@
#include "base/process/process_iterator.h"
#include <errno.h>
-#include <sys/types.h>
#include <stddef.h>
#include <sys/sysctl.h>
+#include <sys/types.h>
#include <unistd.h>
#include "base/logging.h"
@@ -18,10 +18,8 @@
namespace base {
ProcessIterator::ProcessIterator(const ProcessFilter* filter)
- : index_of_kinfo_proc_(),
- filter_(filter) {
-
- int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid() };
+ : index_of_kinfo_proc_(), filter_(filter) {
+ int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid()};
bool done = false;
int try_num = 1;
@@ -40,7 +38,7 @@
num_of_kinfo_proc += 16;
kinfo_procs_.resize(num_of_kinfo_proc);
len = num_of_kinfo_proc * sizeof(struct kinfo_proc);
- if (sysctl(mib, arraysize(mib), &kinfo_procs_[0], &len, NULL, 0) <0) {
+ if (sysctl(mib, arraysize(mib), &kinfo_procs_[0], &len, NULL, 0) < 0) {
// If we get a mem error, it just means we need a bigger buffer, so
// loop around again. Anything else is a real error and give up.
if (errno != ENOMEM) {
@@ -63,8 +61,7 @@
}
}
-ProcessIterator::~ProcessIterator() {
-}
+ProcessIterator::~ProcessIterator() {}
bool ProcessIterator::CheckForNextProcess() {
std::string data;
@@ -72,7 +69,7 @@
for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++index_of_kinfo_proc_) {
size_t length;
struct kinfo_proc kinfo = kinfo_procs_[index_of_kinfo_proc_];
- int mib[] = { CTL_KERN, KERN_PROC_ARGS, kinfo.ki_pid };
+ int mib[] = {CTL_KERN, KERN_PROC_ARGS, kinfo.ki_pid};
if ((kinfo.ki_pid > 0) && (kinfo.ki_stat == SZOMB))
continue;
@@ -92,8 +89,8 @@
std::string delimiters;
delimiters.push_back('\0');
- entry_.cmd_line_args_ = SplitString(data, delimiters,
- KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
+ entry_.cmd_line_args_ =
+ SplitString(data, delimiters, KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
size_t exec_name_end = data.find('\0');
if (exec_name_end == std::string::npos) {
diff --git a/base/process/process_iterator_linux.cc b/base/process/process_iterator_linux.cc
index a7b0b05..9894052 100644
--- a/base/process/process_iterator_linux.cc
+++ b/base/process/process_iterator_linux.cc
@@ -47,8 +47,8 @@
return false;
std::string delimiters;
delimiters.push_back('\0');
- *proc_cmd_line_args = SplitString(cmd_line, delimiters, KEEP_WHITESPACE,
- SPLIT_WANT_NONEMPTY);
+ *proc_cmd_line_args =
+ SplitString(cmd_line, delimiters, KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
return true;
}
diff --git a/base/process/process_iterator_mac.cc b/base/process/process_iterator_mac.cc
index 90d2184..10d712b 100644
--- a/base/process/process_iterator_mac.cc
+++ b/base/process/process_iterator_mac.cc
@@ -18,14 +18,12 @@
namespace base {
ProcessIterator::ProcessIterator(const ProcessFilter* filter)
- : index_of_kinfo_proc_(0),
- filter_(filter) {
+ : index_of_kinfo_proc_(0), filter_(filter) {
// Get a snapshot of all of my processes (yes, as we loop it can go stale, but
// but trying to find where we were in a constantly changing list is basically
// impossible.
- int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID,
- static_cast<int>(geteuid()) };
+ int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_UID, static_cast<int>(geteuid())};
// Since more processes could start between when we get the size and when
// we get the list, we do a loop to keep trying until we get it.
@@ -69,8 +67,7 @@
}
}
-ProcessIterator::~ProcessIterator() {
-}
+ProcessIterator::~ProcessIterator() {}
bool ProcessIterator::CheckForNextProcess() {
std::string data;
@@ -81,7 +78,7 @@
if ((kinfo.kp_proc.p_pid > 0) && (kinfo.kp_proc.p_stat == SZOMB))
continue;
- int mib[] = { CTL_KERN, KERN_PROCARGS, kinfo.kp_proc.p_pid };
+ int mib[] = {CTL_KERN, KERN_PROCARGS, kinfo.kp_proc.p_pid};
// Find out what size buffer we need.
size_t data_len = 0;
@@ -100,8 +97,8 @@
// |entry_.cmd_line_args_|.
std::string delimiters;
delimiters.push_back('\0');
- entry_.cmd_line_args_ = SplitString(data, delimiters,
- KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
+ entry_.cmd_line_args_ =
+ SplitString(data, delimiters, KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
// |data| starts with the full executable path followed by a null character.
// We search for the first instance of '\0' and extract everything before it
diff --git a/base/process/process_iterator_openbsd.cc b/base/process/process_iterator_openbsd.cc
index fa32df4..4362c9a 100644
--- a/base/process/process_iterator_openbsd.cc
+++ b/base/process/process_iterator_openbsd.cc
@@ -16,11 +16,10 @@
namespace base {
ProcessIterator::ProcessIterator(const ProcessFilter* filter)
- : index_of_kinfo_proc_(),
- filter_(filter) {
-
- int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid(),
- sizeof(struct kinfo_proc), 0 };
+ : index_of_kinfo_proc_(), filter_(filter) {
+ int mib[] = {
+ CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid(), sizeof(struct kinfo_proc),
+ 0};
bool done = false;
int try_num = 1;
@@ -62,8 +61,7 @@
}
}
-ProcessIterator::~ProcessIterator() {
-}
+ProcessIterator::~ProcessIterator() {}
bool ProcessIterator::CheckForNextProcess() {
std::string data;
@@ -74,7 +72,7 @@
if ((kinfo.p_pid > 0) && (kinfo.p_stat == SZOMB))
continue;
- int mib[] = { CTL_KERN, KERN_PROC_ARGS, kinfo.p_pid };
+ int mib[] = {CTL_KERN, KERN_PROC_ARGS, kinfo.p_pid};
// Find out what size buffer we need.
size_t data_len = 0;
@@ -93,8 +91,8 @@
// |entry_.cmd_line_args_|.
std::string delimiters;
delimiters.push_back('\0');
- entry_.cmd_line_args_ = SplitString(data, delimiters, KEEP_WHITESPACE,
- SPLIT_WANT_NONEMPTY);
+ entry_.cmd_line_args_ =
+ SplitString(data, delimiters, KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
// |data| starts with the full executable path followed by a null character.
// We search for the first instance of '\0' and extract everything before it
diff --git a/base/process/process_iterator_win.cc b/base/process/process_iterator_win.cc
index 9d5a970..e1bf808 100644
--- a/base/process/process_iterator_win.cc
+++ b/base/process/process_iterator_win.cc
@@ -7,8 +7,7 @@
namespace base {
ProcessIterator::ProcessIterator(const ProcessFilter* filter)
- : started_iteration_(false),
- filter_(filter) {
+ : started_iteration_(false), filter_(filter) {
snapshot_ = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
}
diff --git a/base/process/process_posix.cc b/base/process/process_posix.cc
index 3cc9182..5c9ce05 100644
--- a/base/process/process_posix.cc
+++ b/base/process/process_posix.cc
@@ -162,13 +162,11 @@
DCHECK_EQ(result, 1);
- if (event.filter != EVFILT_PROC ||
- (event.fflags & NOTE_EXIT) == 0 ||
+ if (event.filter != EVFILT_PROC || (event.fflags & NOTE_EXIT) == 0 ||
event.ident != static_cast<uintptr_t>(handle)) {
DLOG(ERROR) << "kevent (wait " << handle
<< "): unexpected event: filter=" << event.filter
- << ", fflags=" << event.fflags
- << ", ident=" << event.ident;
+ << ", fflags=" << event.fflags << ", ident=" << event.ident;
return false;
}
@@ -222,8 +220,7 @@
namespace base {
-Process::Process(ProcessHandle handle) : process_(handle) {
-}
+Process::Process(ProcessHandle handle) : process_(handle) {}
Process::~Process() = default;
diff --git a/base/process/process_win.cc b/base/process/process_win.cc
index f5bd59e..ce2b394 100644
--- a/base/process/process_win.cc
+++ b/base/process/process_win.cc
@@ -13,9 +13,9 @@
namespace {
DWORD kBasicProcessAccess =
- PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION | SYNCHRONIZE;
+ PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION | SYNCHRONIZE;
-} // namespace
+} // namespace
namespace base {
@@ -30,8 +30,7 @@
other.Close();
}
-Process::~Process() {
-}
+Process::~Process() {}
Process& Process::operator=(Process&& other) {
DCHECK_NE(this, &other);
@@ -85,13 +84,9 @@
return Current();
ProcessHandle out_handle;
- if (!IsValid() || !::DuplicateHandle(GetCurrentProcess(),
- Handle(),
- GetCurrentProcess(),
- &out_handle,
- 0,
- FALSE,
- DUPLICATE_SAME_ACCESS)) {
+ if (!IsValid() ||
+ !::DuplicateHandle(GetCurrentProcess(), Handle(), GetCurrentProcess(),
+ &out_handle, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
return Process();
}
return Process(out_handle);
@@ -162,8 +157,7 @@
return true;
}
-void Process::Exited(int exit_code) const {
-}
+void Process::Exited(int exit_code) const {}
int Process::GetPriority() const {
DCHECK(IsValid());
diff --git a/base/scoped_clear_errno.h b/base/scoped_clear_errno.h
index 585f6f7..44a0c62 100644
--- a/base/scoped_clear_errno.h
+++ b/base/scoped_clear_errno.h
@@ -15,9 +15,7 @@
// destruction puts the old value back.
class ScopedClearErrno {
public:
- ScopedClearErrno() : old_errno_(errno) {
- errno = 0;
- }
+ ScopedClearErrno() : old_errno_(errno) { errno = 0; }
~ScopedClearErrno() {
if (errno == 0)
errno = old_errno_;
diff --git a/base/scoped_generic.h b/base/scoped_generic.h
index 25e6208..6a56f64 100644
--- a/base/scoped_generic.h
+++ b/base/scoped_generic.h
@@ -51,7 +51,7 @@
// };
//
// typedef ScopedGeneric<int, FooScopedTraits> ScopedFoo;
-template<typename T, typename Traits>
+template <typename T, typename Traits>
class ScopedGeneric {
private:
// This must be first since it's used inline below.
@@ -78,17 +78,13 @@
// Constructor. Allows initialization of a stateful traits object.
ScopedGeneric(const element_type& value, const traits_type& traits)
- : data_(value, traits) {
- }
+ : data_(value, traits) {}
// Move constructor. Allows initialization from a ScopedGeneric rvalue.
ScopedGeneric(ScopedGeneric<T, Traits>&& rvalue)
- : data_(rvalue.release(), rvalue.get_traits()) {
- }
+ : data_(rvalue.release(), rvalue.get_traits()) {}
- ~ScopedGeneric() {
- FreeIfNecessary();
- }
+ ~ScopedGeneric() { FreeIfNecessary(); }
// operator=. Allows assignment from a ScopedGeneric rvalue.
ScopedGeneric& operator=(ScopedGeneric<T, Traits>&& rvalue) {
@@ -158,28 +154,28 @@
// Forbid comparison. If U != T, it totally doesn't make sense, and if U ==
// T, it still doesn't make sense because you should never have the same
// object owned by two different ScopedGenerics.
- template <typename T2, typename Traits2> bool operator==(
- const ScopedGeneric<T2, Traits2>& p2) const;
- template <typename T2, typename Traits2> bool operator!=(
- const ScopedGeneric<T2, Traits2>& p2) const;
+ template <typename T2, typename Traits2>
+ bool operator==(const ScopedGeneric<T2, Traits2>& p2) const;
+ template <typename T2, typename Traits2>
+ bool operator!=(const ScopedGeneric<T2, Traits2>& p2) const;
Data data_;
DISALLOW_COPY_AND_ASSIGN(ScopedGeneric);
};
-template<class T, class Traits>
+template <class T, class Traits>
void swap(const ScopedGeneric<T, Traits>& a,
const ScopedGeneric<T, Traits>& b) {
a.swap(b);
}
-template<class T, class Traits>
+template <class T, class Traits>
bool operator==(const T& value, const ScopedGeneric<T, Traits>& scoped) {
return value == scoped.get();
}
-template<class T, class Traits>
+template <class T, class Traits>
bool operator!=(const T& value, const ScopedGeneric<T, Traits>& scoped) {
return value != scoped.get();
}
diff --git a/base/sha1.cc b/base/sha1.cc
index a710001..9c22be1 100644
--- a/base/sha1.cc
+++ b/base/sha1.cc
@@ -78,7 +78,7 @@
}
static inline uint32_t S(uint32_t n, uint32_t X) {
- return (X << n) | (X >> (32-n));
+ return (X << n) | (X >> (32 - n));
}
static inline uint32_t K(uint32_t t) {
@@ -131,7 +131,7 @@
void SecureHashAlgorithm::Pad() {
M[cursor++] = 0x80;
- if (cursor > 64-8) {
+ if (cursor > 64 - 8) {
// pad out to next block
while (cursor < 64)
M[cursor++] = 0;
@@ -139,7 +139,7 @@
Process();
}
- while (cursor < 64-8)
+ while (cursor < 64 - 8)
M[cursor++] = 0;
M[cursor++] = (l >> 56) & 0xff;
@@ -202,8 +202,7 @@
return std::string(hash, SecureHashAlgorithm::kDigestSizeBytes);
}
-void SHA1HashBytes(const unsigned char* data, size_t len,
- unsigned char* hash) {
+void SHA1HashBytes(const unsigned char* data, size_t len, unsigned char* hash) {
SecureHashAlgorithm sha;
sha.Update(data, len);
sha.Final();
diff --git a/base/sha1.h b/base/sha1.h
index 5394606..482ebe6 100644
--- a/base/sha1.h
+++ b/base/sha1.h
@@ -9,7 +9,6 @@
#include <string>
-
namespace base {
// These functions perform SHA-1 operations.
@@ -22,8 +21,7 @@
// Computes the SHA-1 hash of the |len| bytes in |data| and puts the hash
// in |hash|. |hash| must be kSHA1Length bytes long.
-void SHA1HashBytes(const unsigned char* data, size_t len,
- unsigned char* hash);
+void SHA1HashBytes(const unsigned char* data, size_t len, unsigned char* hash);
} // namespace base
diff --git a/base/stl_util.h b/base/stl_util.h
index 6d521cc..d9e3484 100644
--- a/base/stl_util.h
+++ b/base/stl_util.h
@@ -117,7 +117,7 @@
// Clears internal memory of an STL object.
// STL clear()/reserve(0) does not always free internal memory allocated
// This function uses swap/destructor to ensure the internal memory is freed.
-template<class T>
+template <class T>
void STLClearObject(T* obj) {
T tmp;
tmp.swap(*obj);
@@ -175,8 +175,8 @@
// Note: Use reverse iterator on container to ensure we only require
// value_type to implement operator<.
return std::adjacent_find(cont.rbegin(), cont.rend(),
- std::less<typename Container::value_type>())
- == cont.rend();
+ std::less<typename Container::value_type>()) ==
+ cont.rend();
}
// Returns a new ResultType containing the difference of two sorted containers.
@@ -185,8 +185,7 @@
DCHECK(STLIsSorted(a1));
DCHECK(STLIsSorted(a2));
ResultType difference;
- std::set_difference(a1.begin(), a1.end(),
- a2.begin(), a2.end(),
+ std::set_difference(a1.begin(), a1.end(), a2.begin(), a2.end(),
std::inserter(difference, difference.end()));
return difference;
}
@@ -197,8 +196,7 @@
DCHECK(STLIsSorted(a1));
DCHECK(STLIsSorted(a2));
ResultType result;
- std::set_union(a1.begin(), a1.end(),
- a2.begin(), a2.end(),
+ std::set_union(a1.begin(), a1.end(), a2.begin(), a2.end(),
std::inserter(result, result.end()));
return result;
}
@@ -210,8 +208,7 @@
DCHECK(STLIsSorted(a1));
DCHECK(STLIsSorted(a2));
ResultType result;
- std::set_intersection(a1.begin(), a1.end(),
- a2.begin(), a2.end(),
+ std::set_intersection(a1.begin(), a1.end(), a2.begin(), a2.end(),
std::inserter(result, result.end()));
return result;
}
@@ -222,8 +219,7 @@
bool STLIncludes(const Arg1& a1, const Arg2& a2) {
DCHECK(STLIsSorted(a1));
DCHECK(STLIsSorted(a2));
- return std::includes(a1.begin(), a1.end(),
- a2.begin(), a2.end());
+ return std::includes(a1.begin(), a1.end(), a2.begin(), a2.end());
}
// Erase/EraseIf are based on library fundamentals ts v2 erase/erase_if
diff --git a/base/strings/string16.cc b/base/strings/string16.cc
index 2abb0e5..997ab20 100644
--- a/base/strings/string16.cc
+++ b/base/strings/string16.cc
@@ -33,7 +33,7 @@
}
size_t c16len(const char16* s) {
- const char16 *s_orig = s;
+ const char16* s_orig = s;
while (*s) {
++s;
}
@@ -59,7 +59,7 @@
}
char16* c16memset(char16* s, char16 c, size_t n) {
- char16 *s_orig = s;
+ char16* s_orig = s;
while (n-- > 0) {
*s = c;
++s;
diff --git a/base/strings/string16.h b/base/strings/string16.h
index b143375..e79aee8 100644
--- a/base/strings/string16.h
+++ b/base/strings/string16.h
@@ -80,26 +80,19 @@
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 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 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 size_t length(const char_type* s) { return c16len(s); }
- static const char_type* find(const char_type* s, size_t n,
+ static const char_type* find(const char_type* s,
+ size_t n,
const char_type& a) {
return c16memchr(s, a, n);
}
@@ -120,21 +113,15 @@
return eq_int_type(c, eof()) ? 0 : c;
}
- static char_type to_char_type(const int_type& c) {
- return char_type(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 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);
- }
+ static int_type eof() { return static_cast<int_type>(EOF); }
};
} // namespace string16_internals
@@ -145,8 +132,7 @@
namespace string16_internals {
-extern std::ostream& operator<<(std::ostream& out,
- const string16& str);
+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);
@@ -194,9 +180,8 @@
//
// 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>;
+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
diff --git a/base/strings/string_number_conversions.cc b/base/strings/string_number_conversions.cc
index c2a606f..01375f5 100644
--- a/base/strings/string_number_conversions.cc
+++ b/base/strings/string_number_conversions.cc
@@ -57,11 +57,12 @@
};
// Utility to convert a character to a digit in a given base
-template<typename CHAR, int BASE, bool BASE_LTE_10> class BaseCharToDigit {
-};
+template <typename CHAR, int BASE, bool BASE_LTE_10>
+class BaseCharToDigit {};
// Faster specialization for bases <= 10
-template<typename CHAR, int BASE> class BaseCharToDigit<CHAR, BASE, true> {
+template <typename CHAR, int BASE>
+class BaseCharToDigit<CHAR, BASE, true> {
public:
static bool Convert(CHAR c, uint8_t* digit) {
if (c >= '0' && c < '0' + BASE) {
@@ -73,7 +74,8 @@
};
// Specialization for bases where 10 < base <= 36
-template<typename CHAR, int BASE> class BaseCharToDigit<CHAR, BASE, false> {
+template <typename CHAR, int BASE>
+class BaseCharToDigit<CHAR, BASE, false> {
public:
static bool Convert(CHAR c, uint8_t* digit) {
if (c >= '0' && c <= '9') {
@@ -98,24 +100,25 @@
// is locale independent, whereas the functions we are replacing were
// locale-dependent. TBD what is desired, but for the moment let's not
// introduce a change in behaviour.
-template<typename CHAR> class WhitespaceHelper {
-};
+template <typename CHAR>
+class WhitespaceHelper {};
-template<> class WhitespaceHelper<char> {
+template <>
+class WhitespaceHelper<char> {
public:
static bool Invoke(char c) {
return 0 != isspace(static_cast<unsigned char>(c));
}
};
-template<> class WhitespaceHelper<char16> {
+template <>
+class WhitespaceHelper<char16> {
public:
- static bool Invoke(char16 c) {
- return 0 != iswspace(c);
- }
+ static bool Invoke(char16 c) { return 0 != iswspace(c); }
};
-template<typename CHAR> bool LocalIsWhitespace(CHAR c) {
+template <typename CHAR>
+bool LocalIsWhitespace(CHAR c) {
return WhitespaceHelper<CHAR>::Invoke(c);
}
@@ -125,7 +128,7 @@
// - static functions min, max (returning the minimum and maximum permitted
// values)
// - constant kBase, the base in which to interpret the input
-template<typename IteratorRangeToNumberTraits>
+template <typename IteratorRangeToNumberTraits>
class IteratorRangeToNumber {
public:
typedef IteratorRangeToNumberTraits traits;
@@ -169,10 +172,11 @@
// causes an overflow/underflow
// - a static function, Increment, that appends the next digit appropriately
// according to the sign of the number being parsed.
- template<typename Sign>
+ template <typename Sign>
class Base {
public:
- static bool Invoke(const_iterator begin, const_iterator end,
+ static bool Invoke(const_iterator begin,
+ const_iterator end,
typename traits::value_type* output) {
*output = 0;
@@ -240,24 +244,19 @@
};
};
-template<typename ITERATOR, typename VALUE, int BASE>
+template <typename ITERATOR, typename VALUE, int BASE>
class BaseIteratorRangeToNumberTraits {
public:
typedef ITERATOR iterator_type;
typedef VALUE value_type;
- static value_type min() {
- return std::numeric_limits<value_type>::min();
- }
- static value_type max() {
- return std::numeric_limits<value_type>::max();
- }
+ static value_type min() { return std::numeric_limits<value_type>::min(); }
+ static value_type max() { return std::numeric_limits<value_type>::max(); }
static const int kBase = BASE;
};
-template<typename ITERATOR>
+template <typename ITERATOR>
class BaseHexIteratorRangeToIntTraits
- : public BaseIteratorRangeToNumberTraits<ITERATOR, int, 16> {
-};
+ : public BaseIteratorRangeToNumberTraits<ITERATOR, int, 16> {};
template <typename ITERATOR>
class BaseHexIteratorRangeToUIntTraits
@@ -287,12 +286,11 @@
class StringPieceToNumberTraits
: public BaseIteratorRangeToNumberTraits<StringPiece::const_iterator,
VALUE,
- BASE> {
-};
+ BASE> {};
template <typename VALUE>
bool StringToIntImpl(StringPiece input, VALUE* output) {
- return IteratorRangeToNumber<StringPieceToNumberTraits<VALUE, 10> >::Invoke(
+ return IteratorRangeToNumber<StringPieceToNumberTraits<VALUE, 10>>::Invoke(
input.begin(), input.end(), output);
}
@@ -300,12 +298,11 @@
class StringPiece16ToNumberTraits
: public BaseIteratorRangeToNumberTraits<StringPiece16::const_iterator,
VALUE,
- BASE> {
-};
+ BASE> {};
template <typename VALUE>
bool String16ToIntImpl(StringPiece16 input, VALUE* output) {
- return IteratorRangeToNumber<StringPiece16ToNumberTraits<VALUE, 10> >::Invoke(
+ return IteratorRangeToNumber<StringPiece16ToNumberTraits<VALUE, 10>>::Invoke(
input.begin(), input.end(), output);
}
@@ -423,7 +420,7 @@
bool HexStringToInt(StringPiece input, int* output) {
return IteratorRangeToNumber<HexIteratorRangeToIntTraits>::Invoke(
- input.begin(), input.end(), output);
+ input.begin(), input.end(), output);
}
bool HexStringToUInt(StringPiece input, uint32_t* output) {
@@ -433,7 +430,7 @@
bool HexStringToInt64(StringPiece input, int64_t* output) {
return IteratorRangeToNumber<HexIteratorRangeToInt64Traits>::Invoke(
- input.begin(), input.end(), output);
+ input.begin(), input.end(), output);
}
bool HexStringToUInt64(StringPiece input, uint64_t* output) {
diff --git a/base/strings/string_number_conversions.h b/base/strings/string_number_conversions.h
index d31f09b..e89e26b 100644
--- a/base/strings/string_number_conversions.h
+++ b/base/strings/string_number_conversions.h
@@ -145,8 +145,7 @@
// |*output| will contain as many bytes as were successfully parsed prior to the
// error. There is no overflow, but input.size() must be evenly divisible by 2.
// Leading 0x or +/- are not allowed.
-bool HexStringToBytes(StringPiece input,
- std::vector<uint8_t>* output);
+bool HexStringToBytes(StringPiece input, std::vector<uint8_t>* output);
} // namespace base
diff --git a/base/strings/string_piece.cc b/base/strings/string_piece.cc
index be22261..612298a 100644
--- a/base/strings/string_piece.cc
+++ b/base/strings/string_piece.cc
@@ -55,7 +55,7 @@
namespace internal {
-template<typename STR>
+template <typename STR>
void CopyToStringT(const BasicStringPiece<STR>& self, STR* target) {
if (self.empty())
target->clear();
@@ -71,7 +71,7 @@
CopyToStringT(self, target);
}
-template<typename STR>
+template <typename STR>
void AppendToStringT(const BasicStringPiece<STR>& self, STR* target) {
if (!self.empty())
target->append(self.data(), self.size());
@@ -85,7 +85,7 @@
AppendToStringT(self, target);
}
-template<typename STR>
+template <typename STR>
size_t copyT(const BasicStringPiece<STR>& self,
typename STR::value_type* buf,
size_t n,
@@ -103,7 +103,7 @@
return copyT(self, buf, n, pos);
}
-template<typename STR>
+template <typename STR>
size_t findT(const BasicStringPiece<STR>& self,
const BasicStringPiece<STR>& s,
size_t pos) {
@@ -112,8 +112,7 @@
typename BasicStringPiece<STR>::const_iterator result =
std::search(self.begin() + pos, self.end(), s.begin(), s.end());
- const size_t xpos =
- static_cast<size_t>(result - self.begin());
+ const size_t xpos = static_cast<size_t>(result - self.begin());
return xpos + s.size() <= self.size() ? xpos : BasicStringPiece<STR>::npos;
}
@@ -125,7 +124,7 @@
return findT(self, s, pos);
}
-template<typename STR>
+template <typename STR>
size_t findT(const BasicStringPiece<STR>& self,
typename STR::value_type c,
size_t pos) {
@@ -134,8 +133,8 @@
typename BasicStringPiece<STR>::const_iterator result =
std::find(self.begin() + pos, self.end(), c);
- return result != self.end() ?
- static_cast<size_t>(result - self.begin()) : BasicStringPiece<STR>::npos;
+ return result != self.end() ? static_cast<size_t>(result - self.begin())
+ : BasicStringPiece<STR>::npos;
}
size_t find(const StringPiece& self, char c, size_t pos) {
@@ -146,7 +145,7 @@
return findT(self, c, pos);
}
-template<typename STR>
+template <typename STR>
size_t rfindT(const BasicStringPiece<STR>& self,
const BasicStringPiece<STR>& s,
size_t pos) {
@@ -160,8 +159,8 @@
self.begin() + std::min(self.size() - s.size(), pos) + s.size();
typename BasicStringPiece<STR>::const_iterator result =
std::find_end(self.begin(), last, s.begin(), s.end());
- return result != last ?
- static_cast<size_t>(result - self.begin()) : BasicStringPiece<STR>::npos;
+ return result != last ? static_cast<size_t>(result - self.begin())
+ : BasicStringPiece<STR>::npos;
}
size_t rfind(const StringPiece& self, const StringPiece& s, size_t pos) {
@@ -172,15 +171,14 @@
return rfindT(self, s, pos);
}
-template<typename STR>
+template <typename STR>
size_t rfindT(const BasicStringPiece<STR>& self,
typename STR::value_type c,
size_t pos) {
if (self.size() == 0)
return BasicStringPiece<STR>::npos;
- for (size_t i = std::min(pos, self.size() - 1); ;
- --i) {
+ for (size_t i = std::min(pos, self.size() - 1);; --i) {
if (self.data()[i] == c)
return i;
if (i == 0)
@@ -208,7 +206,7 @@
if (s.size() == 1)
return find(self, s.data()[0], pos);
- bool lookup[UCHAR_MAX + 1] = { false };
+ bool lookup[UCHAR_MAX + 1] = {false};
BuildLookupTable(s, lookup);
for (size_t i = pos; i < self.size(); ++i) {
if (lookup[static_cast<unsigned char>(self.data()[i])]) {
@@ -243,7 +241,7 @@
if (s.size() == 1)
return find_first_not_of(self, s.data()[0], pos);
- bool lookup[UCHAR_MAX + 1] = { false };
+ bool lookup[UCHAR_MAX + 1] = {false};
BuildLookupTable(s, lookup);
for (size_t i = pos; i < self.size(); ++i) {
if (!lookup[static_cast<unsigned char>(self.data()[i])]) {
@@ -255,8 +253,8 @@
// 16-bit brute-force version.
size_t find_first_not_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos) {
+ const StringPiece16& s,
+ size_t pos) {
if (self.size() == 0)
return StringPiece16::npos;
@@ -274,7 +272,7 @@
return StringPiece16::npos;
}
-template<typename STR>
+template <typename STR>
size_t find_first_not_ofT(const BasicStringPiece<STR>& self,
typename STR::value_type c,
size_t pos) {
@@ -289,15 +287,11 @@
return BasicStringPiece<STR>::npos;
}
-size_t find_first_not_of(const StringPiece& self,
- char c,
- size_t pos) {
+size_t find_first_not_of(const StringPiece& self, char c, size_t pos) {
return find_first_not_ofT(self, c, pos);
}
-size_t find_first_not_of(const StringPiece16& self,
- char16 c,
- size_t pos) {
+size_t find_first_not_of(const StringPiece16& self, char16 c, size_t pos) {
return find_first_not_ofT(self, c, pos);
}
@@ -310,9 +304,9 @@
if (s.size() == 1)
return rfind(self, s.data()[0], pos);
- bool lookup[UCHAR_MAX + 1] = { false };
+ bool lookup[UCHAR_MAX + 1] = {false};
BuildLookupTable(s, lookup);
- for (size_t i = std::min(pos, self.size() - 1); ; --i) {
+ for (size_t i = std::min(pos, self.size() - 1);; --i) {
if (lookup[static_cast<unsigned char>(self.data()[i])])
return i;
if (i == 0)
@@ -328,8 +322,7 @@
if (self.size() == 0)
return StringPiece16::npos;
- for (size_t self_i = std::min(pos, self.size() - 1); ;
- --self_i) {
+ for (size_t self_i = std::min(pos, self.size() - 1);; --self_i) {
for (size_t s_i = 0; s_i < s.size(); s_i++) {
if (self.data()[self_i] == s[s_i])
return self_i;
@@ -355,9 +348,9 @@
if (s.size() == 1)
return find_last_not_of(self, s.data()[0], pos);
- bool lookup[UCHAR_MAX + 1] = { false };
+ bool lookup[UCHAR_MAX + 1] = {false};
BuildLookupTable(s, lookup);
- for (; ; --i) {
+ for (;; --i) {
if (!lookup[static_cast<unsigned char>(self.data()[i])])
return i;
if (i == 0)
@@ -373,7 +366,7 @@
if (self.size() == 0)
return StringPiece::npos;
- for (size_t self_i = std::min(pos, self.size() - 1); ; --self_i) {
+ for (size_t self_i = std::min(pos, self.size() - 1);; --self_i) {
bool found = false;
for (size_t s_i = 0; s_i < s.size(); s_i++) {
if (self.data()[self_i] == s[s_i]) {
@@ -389,14 +382,14 @@
return StringPiece16::npos;
}
-template<typename STR>
+template <typename STR>
size_t find_last_not_ofT(const BasicStringPiece<STR>& self,
typename STR::value_type c,
size_t pos) {
if (self.size() == 0)
return BasicStringPiece<STR>::npos;
- for (size_t i = std::min(pos, self.size() - 1); ; --i) {
+ for (size_t i = std::min(pos, self.size() - 1);; --i) {
if (self.data()[i] != c)
return i;
if (i == 0)
@@ -405,36 +398,30 @@
return BasicStringPiece<STR>::npos;
}
-size_t find_last_not_of(const StringPiece& self,
- char c,
- size_t pos) {
+size_t find_last_not_of(const StringPiece& self, char c, size_t pos) {
return find_last_not_ofT(self, c, pos);
}
-size_t find_last_not_of(const StringPiece16& self,
- char16 c,
- size_t pos) {
+size_t find_last_not_of(const StringPiece16& self, char16 c, size_t pos) {
return find_last_not_ofT(self, c, pos);
}
-template<typename STR>
+template <typename STR>
BasicStringPiece<STR> substrT(const BasicStringPiece<STR>& self,
size_t pos,
size_t n) {
- if (pos > self.size()) pos = self.size();
- if (n > self.size() - pos) n = self.size() - pos;
+ if (pos > self.size())
+ pos = self.size();
+ if (n > self.size() - pos)
+ n = self.size() - pos;
return BasicStringPiece<STR>(self.data() + pos, n);
}
-StringPiece substr(const StringPiece& self,
- size_t pos,
- size_t n) {
+StringPiece substr(const StringPiece& self, size_t pos, size_t n) {
return substrT(self, pos, n);
}
-StringPiece16 substr(const StringPiece16& self,
- size_t pos,
- size_t n) {
+StringPiece16 substr(const StringPiece16& self, size_t pos, size_t n) {
return substrT(self, pos, n);
}
diff --git a/base/strings/string_piece.h b/base/strings/string_piece.h
index 6b19b80..8e4deae 100644
--- a/base/strings/string_piece.h
+++ b/base/strings/string_piece.h
@@ -51,100 +51,58 @@
void AppendToString(const StringPiece& self, std::string* target);
void AppendToString(const StringPiece16& self, string16* target);
-size_t copy(const StringPiece& self,
- char* buf,
- size_t n,
- size_t pos);
-size_t copy(const StringPiece16& self,
- char16* buf,
- size_t n,
- size_t pos);
+size_t copy(const StringPiece& self, char* buf, size_t n, size_t pos);
+size_t copy(const StringPiece16& self, char16* buf, size_t n, size_t pos);
-size_t find(const StringPiece& self,
- const StringPiece& s,
- size_t pos);
-size_t find(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
-size_t find(const StringPiece& self,
- char c,
- size_t pos);
-size_t find(const StringPiece16& self,
- char16 c,
- size_t pos);
+size_t find(const StringPiece& self, const StringPiece& s, size_t pos);
+size_t find(const StringPiece16& self, const StringPiece16& s, size_t pos);
+size_t find(const StringPiece& self, char c, size_t pos);
+size_t find(const StringPiece16& self, char16 c, size_t pos);
-size_t rfind(const StringPiece& self,
+size_t rfind(const StringPiece& self, const StringPiece& s, size_t pos);
+size_t rfind(const StringPiece16& self, const StringPiece16& s, size_t pos);
+size_t rfind(const StringPiece& self, char c, size_t pos);
+size_t rfind(const StringPiece16& self, char16 c, size_t pos);
+
+size_t find_first_of(const StringPiece& self, const StringPiece& s, size_t pos);
+size_t find_first_of(const StringPiece16& self,
+ const StringPiece16& s,
+ size_t pos);
+
+size_t find_first_not_of(const StringPiece& self,
const StringPiece& s,
size_t pos);
-size_t rfind(const StringPiece16& self,
+size_t find_first_not_of(const StringPiece16& self,
const StringPiece16& s,
size_t pos);
-size_t rfind(const StringPiece& self,
- char c,
- size_t pos);
-size_t rfind(const StringPiece16& self,
- char16 c,
- size_t pos);
+size_t find_first_not_of(const StringPiece& self, char c, size_t pos);
+size_t find_first_not_of(const StringPiece16& self, char16 c, size_t pos);
-size_t find_first_of(const StringPiece& self,
- const StringPiece& s,
- size_t pos);
-size_t find_first_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
-
-size_t find_first_not_of(const StringPiece& self,
- const StringPiece& s,
- size_t pos);
-size_t find_first_not_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
-size_t find_first_not_of(const StringPiece& self,
- char c,
- size_t pos);
-size_t find_first_not_of(const StringPiece16& self,
- char16 c,
- size_t pos);
-
-size_t find_last_of(const StringPiece& self,
- const StringPiece& s,
- size_t pos);
+size_t find_last_of(const StringPiece& self, const StringPiece& s, size_t pos);
size_t find_last_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
-size_t find_last_of(const StringPiece& self,
- char c,
- size_t pos);
-size_t find_last_of(const StringPiece16& self,
- char16 c,
- size_t pos);
+ const StringPiece16& s,
+ size_t pos);
+size_t find_last_of(const StringPiece& self, char c, size_t pos);
+size_t find_last_of(const StringPiece16& self, char16 c, size_t pos);
size_t find_last_not_of(const StringPiece& self,
- const StringPiece& s,
- size_t pos);
+ const StringPiece& s,
+ size_t pos);
size_t find_last_not_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
-size_t find_last_not_of(const StringPiece16& self,
- char16 c,
- size_t pos);
-size_t find_last_not_of(const StringPiece& self,
- char c,
- size_t pos);
+ const StringPiece16& s,
+ size_t pos);
+size_t find_last_not_of(const StringPiece16& self, char16 c, size_t pos);
+size_t find_last_not_of(const StringPiece& self, char c, size_t pos);
-StringPiece substr(const StringPiece& self,
- size_t pos,
- size_t n);
-StringPiece16 substr(const StringPiece16& self,
- size_t pos,
- size_t n);
+StringPiece substr(const StringPiece& self, size_t pos, size_t n);
+StringPiece16 substr(const StringPiece16& self, size_t pos, size_t n);
#if DCHECK_IS_ON()
// Asserts that begin <= end to catch some errors with iterator usage.
void AssertIteratorsInOrder(std::string::const_iterator begin,
- std::string::const_iterator end);
+ std::string::const_iterator end);
void AssertIteratorsInOrder(string16::const_iterator begin,
- string16::const_iterator end);
+ string16::const_iterator end);
#endif
} // namespace internal
@@ -157,7 +115,8 @@
//
// This is templatized by string class type rather than character type, so
// BasicStringPiece<std::string> or BasicStringPiece<base::string16>.
-template <typename STRING_TYPE> class BasicStringPiece {
+template <typename STRING_TYPE>
+class BasicStringPiece {
public:
// Standard STL container boilerplate.
typedef size_t size_type;
@@ -252,8 +211,10 @@
int r = CharTraits<value_type>::compare(
ptr_, x.ptr_, (length_ < x.length_ ? length_ : x.length_));
if (r == 0) {
- if (length_ < x.length_) r = -1;
- else if (length_ > x.length_) r = +1;
+ if (length_ < x.length_)
+ r = -1;
+ else if (length_ > x.length_)
+ r = +1;
}
return r;
}
@@ -271,9 +232,7 @@
const_reverse_iterator rbegin() const {
return const_reverse_iterator(ptr_ + length_);
}
- const_reverse_iterator rend() const {
- return const_reverse_iterator(ptr_);
- }
+ const_reverse_iterator rend() const { return const_reverse_iterator(ptr_); }
size_type max_size() const { return length_; }
size_type capacity() const { return length_; }
@@ -326,8 +285,7 @@
}
// find_first_of: Find the first occurence of one of a set of characters.
- size_type find_first_of(const BasicStringPiece& s,
- size_type pos = 0) const {
+ size_type find_first_of(const BasicStringPiece& s, size_type pos = 0) const {
return internal::find_first_of(*this, s, pos);
}
size_type find_first_of(value_type c, size_type pos = 0) const {
@@ -376,8 +334,8 @@
template <typename STRING_TYPE>
const typename BasicStringPiece<STRING_TYPE>::size_type
-BasicStringPiece<STRING_TYPE>::npos =
- typename BasicStringPiece<STRING_TYPE>::size_type(-1);
+ BasicStringPiece<STRING_TYPE>::npos =
+ typename BasicStringPiece<STRING_TYPE>::size_type(-1);
// MSVC doesn't like complex extern templates and DLLs.
#if !defined(COMPILER_MSVC)
@@ -443,8 +401,7 @@
return !(x < y);
}
-std::ostream& operator<<(std::ostream& o,
- const StringPiece& piece);
+std::ostream& operator<<(std::ostream& o, const StringPiece& piece);
// Hashing ---------------------------------------------------------------------
diff --git a/base/strings/string_split.cc b/base/strings/string_split.cc
index 81e47a6..e9b5c96 100644
--- a/base/strings/string_split.cc
+++ b/base/strings/string_split.cc
@@ -20,25 +20,28 @@
//
// The default converter is a NOP, it works when the OutputType is the
// correct StringPiece.
-template<typename Str, typename OutputType>
+template <typename Str, typename OutputType>
OutputType PieceToOutputType(BasicStringPiece<Str> piece) {
return piece;
}
-template<> // Convert StringPiece to std::string
+template <> // Convert StringPiece to std::string
std::string PieceToOutputType<std::string, std::string>(StringPiece piece) {
return piece.as_string();
}
-template<> // Convert StringPiece16 to string16.
+template <> // Convert StringPiece16 to string16.
string16 PieceToOutputType<string16, string16>(StringPiece16 piece) {
return piece.as_string();
}
// Returns either the ASCII or UTF-16 whitespace.
-template<typename Str> BasicStringPiece<Str> WhitespaceForType();
-template<> StringPiece16 WhitespaceForType<string16>() {
+template <typename Str>
+BasicStringPiece<Str> WhitespaceForType();
+template <>
+StringPiece16 WhitespaceForType<string16>() {
return kWhitespaceUTF16;
}
-template<> StringPiece WhitespaceForType<std::string>() {
+template <>
+StringPiece WhitespaceForType<std::string>() {
return kWhitespaceASCII;
}
@@ -69,12 +72,11 @@
// multiple characters (BasicStringPiece<Str>). StringPiece has a version of
// find for both of these cases, and the single-character version is the most
// common and can be implemented faster, which is why this is a template.
-template<typename Str, typename OutputStringType, typename DelimiterType>
-static std::vector<OutputStringType> SplitStringT(
- BasicStringPiece<Str> str,
- DelimiterType delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type) {
+template <typename Str, typename OutputStringType, typename DelimiterType>
+static std::vector<OutputStringType> SplitStringT(BasicStringPiece<Str> str,
+ DelimiterType delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type) {
std::vector<OutputStringType> result;
if (str.empty())
return result;
@@ -112,7 +114,7 @@
// Find the delimiter.
size_t end_key_pos = input.find_first_of(delimiter);
if (end_key_pos == std::string::npos) {
- return false; // No delimiter.
+ return false; // No delimiter.
}
input.substr(0, end_key_pos).CopyToString(&result_pair.first);
@@ -120,7 +122,7 @@
StringPiece remains = input.substr(end_key_pos, input.size() - end_key_pos);
size_t begin_value_pos = remains.find_first_not_of(delimiter);
if (begin_value_pos == StringPiece::npos) {
- return false; // No value.
+ return false; // No value.
}
remains.substr(begin_value_pos, remains.size() - begin_value_pos)
.CopyToString(&result_pair.second);
@@ -172,8 +174,8 @@
WhitespaceHandling whitespace,
SplitResult result_type) {
if (separators.size() == 1) {
- return SplitStringT<string16, string16, char16>(
- input, separators[0], whitespace, result_type);
+ return SplitStringT<string16, string16, char16>(input, separators[0],
+ whitespace, result_type);
}
return SplitStringT<string16, string16, StringPiece16>(
input, separators, whitespace, result_type);
@@ -209,9 +211,9 @@
StringPairs* key_value_pairs) {
key_value_pairs->clear();
- std::vector<StringPiece> pairs = SplitStringPiece(
- input, std::string(1, key_value_pair_delimiter),
- TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
+ std::vector<StringPiece> pairs =
+ SplitStringPiece(input, std::string(1, key_value_pair_delimiter),
+ TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
key_value_pairs->reserve(pairs.size());
bool success = true;
diff --git a/base/strings/string_split.h b/base/strings/string_split.h
index 1a41d2e..6f8fc7c 100644
--- a/base/strings/string_split.h
+++ b/base/strings/string_split.h
@@ -42,16 +42,14 @@
//
// std::vector<std::string> tokens = base::SplitString(
// input, ",;", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
-std::vector<std::string> SplitString(
- StringPiece input,
- StringPiece separators,
- WhitespaceHandling whitespace,
- SplitResult result_type);
-std::vector<string16> SplitString(
- StringPiece16 input,
- StringPiece16 separators,
- WhitespaceHandling whitespace,
- SplitResult result_type);
+std::vector<std::string> SplitString(StringPiece input,
+ StringPiece separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type);
+std::vector<string16> SplitString(StringPiece16 input,
+ StringPiece16 separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type);
// Like SplitString above except it returns a vector of StringPieces which
// reference the original buffer without copying. Although you have to be
@@ -65,16 +63,14 @@
// base::KEEP_WHITESPACE,
// base::SPLIT_WANT_NONEMPTY)) {
// ...
-std::vector<StringPiece> SplitStringPiece(
- StringPiece input,
- StringPiece separators,
- WhitespaceHandling whitespace,
- SplitResult result_type);
-std::vector<StringPiece16> SplitStringPiece(
- StringPiece16 input,
- StringPiece16 separators,
- WhitespaceHandling whitespace,
- SplitResult result_type);
+std::vector<StringPiece> SplitStringPiece(StringPiece input,
+ StringPiece separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type);
+std::vector<StringPiece16> SplitStringPiece(StringPiece16 input,
+ StringPiece16 separators,
+ WhitespaceHandling whitespace,
+ SplitResult result_type);
using StringPairs = std::vector<std::pair<std::string, std::string>>;
@@ -83,22 +79,20 @@
// only if each pair has a non-empty key and value. |key_value_pairs| will
// include ("","") pairs for entries without |key_value_delimiter|.
bool SplitStringIntoKeyValuePairs(StringPiece input,
- char key_value_delimiter,
- char key_value_pair_delimiter,
- StringPairs* key_value_pairs);
+ char key_value_delimiter,
+ char key_value_pair_delimiter,
+ StringPairs* key_value_pairs);
// Similar to SplitString, but use a substring delimiter instead of a list of
// characters that are all possible delimiters.
-std::vector<string16> SplitStringUsingSubstr(
- StringPiece16 input,
- StringPiece16 delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type);
-std::vector<std::string> SplitStringUsingSubstr(
- StringPiece input,
- StringPiece delimiter,
- WhitespaceHandling whitespace,
- SplitResult result_type);
+std::vector<string16> SplitStringUsingSubstr(StringPiece16 input,
+ StringPiece16 delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type);
+std::vector<std::string> SplitStringUsingSubstr(StringPiece input,
+ StringPiece delimiter,
+ WhitespaceHandling whitespace,
+ SplitResult result_type);
// Like SplitStringUsingSubstr above except it returns a vector of StringPieces
// which reference the original buffer without copying. Although you have to be
diff --git a/base/strings/string_tokenizer.h b/base/strings/string_tokenizer.h
index 72fc016..451a011 100644
--- a/base/strings/string_tokenizer.h
+++ b/base/strings/string_tokenizer.h
@@ -95,8 +95,7 @@
// should not be constructed with a temporary. The deleted rvalue constructor
// blocks the most obvious instances of this (e.g. passing a string literal to
// the constructor), but caution must still be exercised.
- StringTokenizerT(const str& string,
- const str& delims) {
+ StringTokenizerT(const str& string, const str& delims) {
Init(string.begin(), string.end(), delims);
}
@@ -131,9 +130,7 @@
}
// Start iterating through tokens from the beginning of the string.
- void Reset() {
- token_end_ = start_pos_;
- }
+ void Reset() { token_end_ = start_pos_; }
// Returns true if token is a delimiter. When the tokenizer is constructed
// with the RETURN_DELIMS option, this method can be used to check if the
@@ -204,13 +201,9 @@
return true;
}
- bool IsDelim(char_type c) const {
- return delims_.find(c) != str::npos;
- }
+ bool IsDelim(char_type c) const { return delims_.find(c) != str::npos; }
- bool IsQuote(char_type c) const {
- return quotes_.find(c) != str::npos;
- }
+ bool IsQuote(char_type c) const { return quotes_.find(c) != str::npos; }
struct AdvanceState {
bool in_quote;
diff --git a/base/strings/string_util.cc b/base/strings/string_util.cc
index 82ce02c..a387586 100644
--- a/base/strings/string_util.cc
+++ b/base/strings/string_util.cc
@@ -35,8 +35,7 @@
// replaced parameters.
struct ReplacementOffset {
ReplacementOffset(uintptr_t parameter, size_t offset)
- : parameter(parameter),
- offset(offset) {}
+ : parameter(parameter), offset(offset) {}
// Index of the parameter.
uintptr_t parameter;
@@ -74,30 +73,38 @@
return !(reinterpret_cast<MachineWord>(pointer) & kMachineWordAlignmentMask);
}
-template<typename T> inline T* AlignToMachineWord(T* pointer) {
+template <typename T>
+inline T* AlignToMachineWord(T* pointer) {
return reinterpret_cast<T*>(reinterpret_cast<MachineWord>(pointer) &
~kMachineWordAlignmentMask);
}
-template<size_t size, typename CharacterType> struct NonASCIIMask;
-template<> struct NonASCIIMask<4, char16> {
- static inline uint32_t value() { return 0xFF80FF80U; }
+template <size_t size, typename CharacterType>
+struct NonASCIIMask;
+template <>
+struct NonASCIIMask<4, char16> {
+ static inline uint32_t value() { return 0xFF80FF80U; }
};
-template<> struct NonASCIIMask<4, char> {
- static inline uint32_t value() { return 0x80808080U; }
+template <>
+struct NonASCIIMask<4, char> {
+ static inline uint32_t value() { return 0x80808080U; }
};
-template<> struct NonASCIIMask<8, char16> {
- static inline uint64_t value() { return 0xFF80FF80FF80FF80ULL; }
+template <>
+struct NonASCIIMask<8, char16> {
+ static inline uint64_t value() { return 0xFF80FF80FF80FF80ULL; }
};
-template<> struct NonASCIIMask<8, char> {
- static inline uint64_t value() { return 0x8080808080808080ULL; }
+template <>
+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<4, wchar_t> {
+ static inline uint32_t value() { return 0xFFFFFF80U; }
};
-template<> struct NonASCIIMask<8, wchar_t> {
- static inline uint64_t value() { return 0xFFFFFF80FFFFFF80ULL; }
+template <>
+struct NonASCIIMask<8, wchar_t> {
+ static inline uint64_t value() { return 0xFFFFFF80FFFFFF80ULL; }
};
#endif // WCHAR_T_IS_UTF32
@@ -140,7 +147,7 @@
namespace {
-template<typename StringType>
+template <typename StringType>
StringType ToLowerASCIIImpl(BasicStringPiece<StringType> str) {
StringType ret;
ret.reserve(str.size());
@@ -149,7 +156,7 @@
return ret;
}
-template<typename StringType>
+template <typename StringType>
StringType ToUpperASCIIImpl(BasicStringPiece<StringType> str) {
StringType ret;
ret.reserve(str.size());
@@ -176,7 +183,7 @@
return ToUpperASCIIImpl<string16>(str);
}
-template<class StringType>
+template <class StringType>
int CompareCaseInsensitiveASCIIT(BasicStringPiece<StringType> a,
BasicStringPiece<StringType> b) {
// Find the first characters that aren't equal and compare them. If the end
@@ -256,7 +263,7 @@
return ReplaceCharsT(input, remove_chars, StringPiece(), output);
}
-template<typename Str>
+template <typename Str>
TrimPositions TrimStringT(const Str& input,
BasicStringPiece<Str> trim_chars,
TrimPositions positions,
@@ -267,24 +274,25 @@
// constant so avoid making a copy).
BasicStringPiece<Str> input_piece(input);
const size_t last_char = input.length() - 1;
- const size_t first_good_char = (positions & TRIM_LEADING) ?
- input_piece.find_first_not_of(trim_chars) : 0;
- const size_t last_good_char = (positions & TRIM_TRAILING) ?
- input_piece.find_last_not_of(trim_chars) : last_char;
+ const size_t first_good_char = (positions & TRIM_LEADING)
+ ? input_piece.find_first_not_of(trim_chars)
+ : 0;
+ const size_t last_good_char = (positions & TRIM_TRAILING)
+ ? input_piece.find_last_not_of(trim_chars)
+ : last_char;
// When the string was all trimmed, report that we stripped off characters
// from whichever position the caller was interested in. For empty input, we
// stripped no characters, but we still need to clear |output|.
- if (input.empty() ||
- (first_good_char == Str::npos) || (last_good_char == Str::npos)) {
+ if (input.empty() || (first_good_char == Str::npos) ||
+ (last_good_char == Str::npos)) {
bool input_was_empty = input.empty(); // in case output == &input
output->clear();
return input_was_empty ? TRIM_NONE : positions;
}
// Trim.
- *output =
- input.substr(first_good_char, last_good_char - first_good_char + 1);
+ *output = input.substr(first_good_char, last_good_char - first_good_char + 1);
// Return where we trimmed from.
return static_cast<TrimPositions>(
@@ -304,14 +312,15 @@
return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
}
-template<typename Str>
+template <typename Str>
BasicStringPiece<Str> TrimStringPieceT(BasicStringPiece<Str> input,
BasicStringPiece<Str> trim_chars,
TrimPositions positions) {
- size_t begin = (positions & TRIM_LEADING) ?
- input.find_first_not_of(trim_chars) : 0;
- size_t end = (positions & TRIM_TRAILING) ?
- input.find_last_not_of(trim_chars) + 1 : input.size();
+ size_t begin =
+ (positions & TRIM_LEADING) ? input.find_first_not_of(trim_chars) : 0;
+ size_t end = (positions & TRIM_TRAILING)
+ ? input.find_last_not_of(trim_chars) + 1
+ : input.size();
return input.substr(begin, end - begin);
}
@@ -350,15 +359,14 @@
int32_t prev = char_index;
base_icu::UChar32 code_point = 0;
CBU8_NEXT(data, char_index, truncation_length, code_point);
- if (!IsValidCharacter(code_point) ||
- !IsValidCodepoint(code_point)) {
+ if (!IsValidCharacter(code_point) || !IsValidCodepoint(code_point)) {
char_index = prev - 1;
} else {
break;
}
}
- if (char_index >= 0 )
+ if (char_index >= 0)
*output = input.substr(0, char_index);
else
output->clear();
@@ -370,8 +378,7 @@
return TrimStringT(input, StringPiece16(kWhitespaceUTF16), positions, output);
}
-StringPiece16 TrimWhitespace(StringPiece16 input,
- TrimPositions positions) {
+StringPiece16 TrimWhitespace(StringPiece16 input, TrimPositions positions) {
return TrimStringPieceT(input, StringPiece16(kWhitespaceUTF16), positions);
}
@@ -385,9 +392,8 @@
return TrimStringPieceT(input, StringPiece(kWhitespaceASCII), positions);
}
-template<typename STR>
-STR CollapseWhitespaceT(const STR& text,
- bool trim_sequences_with_line_breaks) {
+template <typename STR>
+STR CollapseWhitespaceT(const STR& text, bool trim_sequences_with_line_breaks) {
STR result;
result.resize(text.size());
@@ -490,7 +496,7 @@
#endif
bool IsStringUTF8(StringPiece str) {
- const char *src = str.data();
+ const char* src = str.data();
int32_t src_len = static_cast<int32_t>(str.length());
int32_t char_index = 0;
@@ -518,7 +524,7 @@
// The hardcoded strings are typically very short so it doesn't matter, and the
// string piece gives additional flexibility for the caller (doesn't have to be
// null terminated) so we choose the StringPiece route.
-template<typename Str>
+template <typename Str>
static inline bool DoLowerCaseEqualsASCII(BasicStringPiece<Str> str,
StringPiece lowercase_ascii) {
if (str.size() != lowercase_ascii.size())
@@ -544,7 +550,7 @@
return std::equal(ascii.begin(), ascii.end(), str.begin());
}
-template<typename Str>
+template <typename Str>
bool StartsWithT(BasicStringPiece<Str> str,
BasicStringPiece<Str> search_for,
CompareCase case_sensitivity) {
@@ -559,8 +565,7 @@
case CompareCase::INSENSITIVE_ASCII:
return std::equal(
- search_for.begin(), search_for.end(),
- source.begin(),
+ search_for.begin(), search_for.end(), source.begin(),
CaseInsensitiveCompareASCII<typename Str::value_type>());
default:
@@ -588,8 +593,8 @@
if (search_for.size() > str.size())
return false;
- BasicStringPiece<Str> source = str.substr(str.size() - search_for.size(),
- search_for.size());
+ BasicStringPiece<Str> source =
+ str.substr(str.size() - search_for.size(), search_for.size());
switch (case_sensitivity) {
case CompareCase::SENSITIVE:
@@ -597,8 +602,7 @@
case CompareCase::INSENSITIVE_ASCII:
return std::equal(
- source.begin(), source.end(),
- search_for.begin(),
+ source.begin(), source.end(), search_for.begin(),
CaseInsensitiveCompareASCII<typename Str::value_type>());
default:
@@ -639,14 +643,8 @@
return false;
}
-static const char* const kByteStringsUnlocalized[] = {
- " B",
- " kB",
- " MB",
- " GB",
- " TB",
- " PB"
-};
+static const char* const kByteStringsUnlocalized[] = {" B", " kB", " MB",
+ " GB", " TB", " PB"};
string16 FormatBytesUnlocalized(int64_t bytes) {
double unit_amount = static_cast<double>(bytes);
@@ -987,7 +985,7 @@
return JoinStringT(parts, separator);
}
-template<class FormatStringType, class OutStringType>
+template <class FormatStringType, class OutStringType>
OutStringType DoReplaceStringPlaceholders(
const FormatStringType& format_string,
const std::vector<OutStringType>& subst,
@@ -1086,7 +1084,8 @@
dst[dst_size - 1] = 0;
// Count the rest of the |src|, and return it's length in characters.
- while (src[dst_size]) ++dst_size;
+ while (src[dst_size])
+ ++dst_size;
return dst_size;
}
diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index 98197d6..5403ada 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -8,7 +8,7 @@
#define BASE_STRINGS_STRING_UTIL_H_
#include <ctype.h>
-#include <stdarg.h> // va_list
+#include <stdarg.h> // va_list
#include <stddef.h>
#include <stdint.h>
@@ -119,7 +119,8 @@
// context (combining accents), and require handling UTF-16. If you need
// proper Unicode support, use base::i18n::ToLower/FoldCase and then just
// use a normal operator== on the result.
-template<typename Char> struct CaseInsensitiveCompareASCII {
+template <typename Char>
+struct CaseInsensitiveCompareASCII {
public:
bool operator()(Char x, Char y) const {
return ToLowerASCII(x) == ToLowerASCII(y);
@@ -157,11 +158,11 @@
// if any characters were removed. |remove_chars| must be null-terminated.
// NOTE: Safe to use the same variable for both |input| and |output|.
bool RemoveChars(const string16& input,
- StringPiece16 remove_chars,
- string16* output);
+ StringPiece16 remove_chars,
+ string16* output);
bool RemoveChars(const std::string& input,
- StringPiece remove_chars,
- std::string* output);
+ StringPiece remove_chars,
+ std::string* output);
// Replaces characters in |replace_chars| from anywhere in |input| with
// |replace_with|. Each character in |replace_chars| will be replaced with
@@ -169,19 +170,19 @@
// |replace_chars| must be null-terminated.
// NOTE: Safe to use the same variable for both |input| and |output|.
bool ReplaceChars(const string16& input,
- StringPiece16 replace_chars,
- const string16& replace_with,
- string16* output);
+ StringPiece16 replace_chars,
+ const string16& replace_with,
+ string16* output);
bool ReplaceChars(const std::string& input,
- StringPiece replace_chars,
- const std::string& replace_with,
- std::string* output);
+ StringPiece replace_chars,
+ const std::string& replace_with,
+ std::string* output);
enum TrimPositions {
- TRIM_NONE = 0,
- TRIM_LEADING = 1 << 0,
+ TRIM_NONE = 0,
+ TRIM_LEADING = 1 << 0,
TRIM_TRAILING = 1 << 1,
- TRIM_ALL = TRIM_LEADING | TRIM_TRAILING,
+ TRIM_ALL = TRIM_LEADING | TRIM_TRAILING,
};
// Removes characters in |trim_chars| from the beginning and end of |input|.
@@ -191,26 +192,26 @@
// It is safe to use the same variable for both |input| and |output| (this is
// the normal usage to trim in-place).
bool TrimString(const string16& input,
- StringPiece16 trim_chars,
- string16* output);
+ StringPiece16 trim_chars,
+ string16* output);
bool TrimString(const std::string& input,
- StringPiece trim_chars,
- std::string* output);
+ StringPiece trim_chars,
+ std::string* output);
// StringPiece versions of the above. The returned pieces refer to the original
// buffer.
StringPiece16 TrimString(StringPiece16 input,
- StringPiece16 trim_chars,
- TrimPositions positions);
+ StringPiece16 trim_chars,
+ TrimPositions positions);
StringPiece TrimString(StringPiece input,
- StringPiece trim_chars,
- TrimPositions positions);
+ StringPiece trim_chars,
+ TrimPositions positions);
// Truncates a string to the nearest UTF-8 character that will leave
// the string less than or equal to the specified byte size.
void TruncateUTF8ToByteSize(const std::string& input,
- const size_t byte_size,
- std::string* output);
+ const size_t byte_size,
+ std::string* output);
// Trims any whitespace from either end of the input string.
//
@@ -220,15 +221,13 @@
// The std::string versions return where whitespace was found.
// NOTE: Safe to use the same variable for both input and output.
TrimPositions TrimWhitespace(const string16& input,
- TrimPositions positions,
- string16* output);
-StringPiece16 TrimWhitespace(StringPiece16 input,
- TrimPositions positions);
+ TrimPositions positions,
+ string16* output);
+StringPiece16 TrimWhitespace(StringPiece16 input, TrimPositions positions);
TrimPositions TrimWhitespaceASCII(const std::string& input,
- TrimPositions positions,
- std::string* output);
-StringPiece TrimWhitespaceASCII(StringPiece input,
- TrimPositions positions);
+ TrimPositions positions,
+ std::string* output);
+StringPiece TrimWhitespaceASCII(StringPiece input, TrimPositions positions);
// Searches for CR or LF characters. Removes all contiguous whitespace
// strings that contain them. This is useful when trying to deal with text
@@ -238,18 +237,15 @@
// (2) If |trim_sequences_with_line_breaks| is true, any other whitespace
// sequences containing a CR or LF are trimmed.
// (3) All other whitespace sequences are converted to single spaces.
-string16 CollapseWhitespace(
- const string16& text,
- bool trim_sequences_with_line_breaks);
-std::string CollapseWhitespaceASCII(
- const std::string& text,
- bool trim_sequences_with_line_breaks);
+string16 CollapseWhitespace(const string16& text,
+ bool trim_sequences_with_line_breaks);
+std::string CollapseWhitespaceASCII(const std::string& text,
+ bool trim_sequences_with_line_breaks);
// Returns true if |input| is empty or contains only characters found in
// |characters|.
bool ContainsOnlyChars(StringPiece input, StringPiece characters);
-bool ContainsOnlyChars(StringPiece16 input,
- StringPiece16 characters);
+bool ContainsOnlyChars(StringPiece16 input, StringPiece16 characters);
// Returns true if the specified string matches the criteria. How can a wide
// string be 8-bit or UTF8? It contains only characters that are < 256 (in the
@@ -274,10 +270,8 @@
// Compare the lower-case form of the given string against the given
// previously-lower-cased ASCII string (typically a constant).
-bool LowerCaseEqualsASCII(StringPiece str,
- StringPiece lowecase_ascii);
-bool LowerCaseEqualsASCII(StringPiece16 str,
- StringPiece lowecase_ascii);
+bool LowerCaseEqualsASCII(StringPiece str, StringPiece lowecase_ascii);
+bool LowerCaseEqualsASCII(StringPiece16 str, StringPiece lowecase_ascii);
// Performs a case-sensitive string compare of the given 16-bit string against
// the given 8-bit ASCII string (typically a constant). The behavior is
@@ -298,17 +292,17 @@
};
bool StartsWith(StringPiece str,
- StringPiece search_for,
- CompareCase case_sensitivity);
+ StringPiece search_for,
+ CompareCase case_sensitivity);
bool StartsWith(StringPiece16 str,
- StringPiece16 search_for,
- CompareCase case_sensitivity);
+ StringPiece16 search_for,
+ CompareCase case_sensitivity);
bool EndsWith(StringPiece str,
- StringPiece search_for,
- CompareCase case_sensitivity);
+ StringPiece search_for,
+ CompareCase case_sensitivity);
bool EndsWith(StringPiece16 str,
- StringPiece16 search_for,
- CompareCase case_sensitivity);
+ StringPiece16 search_for,
+ CompareCase case_sensitivity);
// Determines the type of ASCII character, independent of locale (the C
// library versions will change based on locale).
@@ -335,8 +329,7 @@
template <typename Char>
inline bool IsHexDigit(Char c) {
- return (c >= '0' && c <= '9') ||
- (c >= 'A' && c <= 'F') ||
+ return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') ||
(c >= 'a' && c <= 'f');
}
@@ -358,16 +351,14 @@
// Starting at |start_offset| (usually 0), replace the first instance of
// |find_this| with |replace_with|.
-void ReplaceFirstSubstringAfterOffset(
- base::string16* str,
- size_t start_offset,
- StringPiece16 find_this,
- StringPiece16 replace_with);
-void ReplaceFirstSubstringAfterOffset(
- std::string* str,
- size_t start_offset,
- StringPiece find_this,
- StringPiece replace_with);
+void ReplaceFirstSubstringAfterOffset(base::string16* str,
+ size_t start_offset,
+ StringPiece16 find_this,
+ StringPiece16 replace_with);
+void ReplaceFirstSubstringAfterOffset(std::string* str,
+ size_t start_offset,
+ StringPiece find_this,
+ StringPiece replace_with);
// Starting at |start_offset| (usually 0), look through |str| and replace all
// instances of |find_this| with |replace_with|.
@@ -375,16 +366,14 @@
// This does entire substrings; use std::replace in <algorithm> for single
// characters, for example:
// std::replace(str.begin(), str.end(), 'a', 'b');
-void ReplaceSubstringsAfterOffset(
- string16* str,
- size_t start_offset,
- StringPiece16 find_this,
- StringPiece16 replace_with);
-void ReplaceSubstringsAfterOffset(
- std::string* str,
- size_t start_offset,
- StringPiece find_this,
- StringPiece replace_with);
+void ReplaceSubstringsAfterOffset(string16* str,
+ size_t start_offset,
+ StringPiece16 find_this,
+ StringPiece16 replace_with);
+void ReplaceSubstringsAfterOffset(std::string* str,
+ size_t start_offset,
+ StringPiece find_this,
+ StringPiece replace_with);
// Reserves enough memory in |str| to accommodate |length_with_null| characters,
// sets the size of |str| to |length_with_null - 1| characters, and returns a
@@ -421,39 +410,37 @@
//
// Use StrCat (in base/strings/strcat.h) if you don't need a separator.
std::string JoinString(const std::vector<std::string>& parts,
- StringPiece separator);
+ StringPiece separator);
string16 JoinString(const std::vector<string16>& parts,
- StringPiece16 separator);
+ StringPiece16 separator);
std::string JoinString(const std::vector<StringPiece>& parts,
- StringPiece separator);
+ StringPiece separator);
string16 JoinString(const std::vector<StringPiece16>& parts,
- StringPiece16 separator);
+ StringPiece16 separator);
// Explicit initializer_list overloads are required to break ambiguity when used
// with a literal initializer list (otherwise the compiler would not be able to
// decide between the string and StringPiece overloads).
std::string JoinString(std::initializer_list<StringPiece> parts,
- StringPiece separator);
+ StringPiece separator);
string16 JoinString(std::initializer_list<StringPiece16> parts,
- StringPiece16 separator);
+ StringPiece16 separator);
// Replace $1-$2-$3..$9 in the format string with values from |subst|.
// Additionally, any number of consecutive '$' characters is replaced by that
// number less one. Eg $$->$, $$$->$$, etc. The offsets parameter here can be
// NULL. This only allows you to use up to nine replacements.
-string16 ReplaceStringPlaceholders(
- const string16& format_string,
- const std::vector<string16>& subst,
- std::vector<size_t>* offsets);
+string16 ReplaceStringPlaceholders(const string16& format_string,
+ const std::vector<string16>& subst,
+ std::vector<size_t>* offsets);
-std::string ReplaceStringPlaceholders(
- StringPiece format_string,
- const std::vector<std::string>& subst,
- std::vector<size_t>* offsets);
+std::string ReplaceStringPlaceholders(StringPiece format_string,
+ const std::vector<std::string>& subst,
+ std::vector<size_t>* offsets);
// Single-string shortcut for ReplaceStringHolders. |offset| may be NULL.
string16 ReplaceStringPlaceholders(const string16& format_string,
- const string16& a,
- size_t* offset);
+ const string16& a,
+ size_t* offset);
} // namespace base
diff --git a/base/strings/string_util_constants.cc b/base/strings/string_util_constants.cc
index aba1b12..37ff95f 100644
--- a/base/strings/string_util_constants.cc
+++ b/base/strings/string_util_constants.cc
@@ -6,61 +6,53 @@
namespace base {
-#define WHITESPACE_UNICODE \
- 0x0009, /* CHARACTER TABULATION */ \
- 0x000A, /* LINE FEED (LF) */ \
- 0x000B, /* LINE TABULATION */ \
- 0x000C, /* FORM FEED (FF) */ \
- 0x000D, /* CARRIAGE RETURN (CR) */ \
- 0x0020, /* SPACE */ \
- 0x0085, /* NEXT LINE (NEL) */ \
- 0x00A0, /* NO-BREAK SPACE */ \
- 0x1680, /* OGHAM SPACE MARK */ \
- 0x2000, /* EN QUAD */ \
- 0x2001, /* EM QUAD */ \
- 0x2002, /* EN SPACE */ \
- 0x2003, /* EM SPACE */ \
- 0x2004, /* THREE-PER-EM SPACE */ \
- 0x2005, /* FOUR-PER-EM SPACE */ \
- 0x2006, /* SIX-PER-EM SPACE */ \
- 0x2007, /* FIGURE SPACE */ \
- 0x2008, /* PUNCTUATION SPACE */ \
- 0x2009, /* THIN SPACE */ \
- 0x200A, /* HAIR SPACE */ \
- 0x2028, /* LINE SEPARATOR */ \
- 0x2029, /* PARAGRAPH SEPARATOR */ \
- 0x202F, /* NARROW NO-BREAK SPACE */ \
- 0x205F, /* MEDIUM MATHEMATICAL SPACE */ \
- 0x3000, /* IDEOGRAPHIC SPACE */ \
- 0
+#define WHITESPACE_UNICODE \
+ 0x0009, /* CHARACTER TABULATION */ \
+ 0x000A, /* LINE FEED (LF) */ \
+ 0x000B, /* LINE TABULATION */ \
+ 0x000C, /* FORM FEED (FF) */ \
+ 0x000D, /* CARRIAGE RETURN (CR) */ \
+ 0x0020, /* SPACE */ \
+ 0x0085, /* NEXT LINE (NEL) */ \
+ 0x00A0, /* NO-BREAK SPACE */ \
+ 0x1680, /* OGHAM SPACE MARK */ \
+ 0x2000, /* EN QUAD */ \
+ 0x2001, /* EM QUAD */ \
+ 0x2002, /* EN SPACE */ \
+ 0x2003, /* EM SPACE */ \
+ 0x2004, /* THREE-PER-EM SPACE */ \
+ 0x2005, /* FOUR-PER-EM SPACE */ \
+ 0x2006, /* SIX-PER-EM SPACE */ \
+ 0x2007, /* FIGURE SPACE */ \
+ 0x2008, /* PUNCTUATION SPACE */ \
+ 0x2009, /* THIN SPACE */ \
+ 0x200A, /* HAIR SPACE */ \
+ 0x2028, /* LINE SEPARATOR */ \
+ 0x2029, /* PARAGRAPH SEPARATOR */ \
+ 0x202F, /* NARROW NO-BREAK SPACE */ \
+ 0x205F, /* MEDIUM MATHEMATICAL SPACE */ \
+ 0x3000, /* IDEOGRAPHIC SPACE */ \
+ 0
-const wchar_t kWhitespaceWide[] = {
- WHITESPACE_UNICODE
-};
+const wchar_t kWhitespaceWide[] = {WHITESPACE_UNICODE};
-const char16 kWhitespaceUTF16[] = {
- WHITESPACE_UNICODE
-};
+const char16 kWhitespaceUTF16[] = {WHITESPACE_UNICODE};
-const char kWhitespaceASCII[] = {
- 0x09, // CHARACTER TABULATION
- 0x0A, // LINE FEED (LF)
- 0x0B, // LINE TABULATION
- 0x0C, // FORM FEED (FF)
- 0x0D, // CARRIAGE RETURN (CR)
- 0x20, // SPACE
- 0
-};
+const char kWhitespaceASCII[] = {0x09, // CHARACTER TABULATION
+ 0x0A, // LINE FEED (LF)
+ 0x0B, // LINE TABULATION
+ 0x0C, // FORM FEED (FF)
+ 0x0D, // CARRIAGE RETURN (CR)
+ 0x20, // SPACE
+ 0};
-const char16 kWhitespaceASCIIAs16[] = {
- 0x09, // CHARACTER TABULATION
- 0x0A, // LINE FEED (LF)
- 0x0B, // LINE TABULATION
- 0x0C, // FORM FEED (FF)
- 0x0D, // CARRIAGE RETURN (CR)
- 0x20, // SPACE
- 0
-};
+const char16 kWhitespaceASCIIAs16[] = {0x09, // CHARACTER TABULATION
+ 0x0A, // LINE FEED (LF)
+ 0x0B, // LINE TABULATION
+ 0x0C, // FORM FEED (FF)
+ 0x0D, // CARRIAGE RETURN (CR)
+ 0x20, // SPACE
+ 0};
const char kUtf8ByteOrderMark[] = "\xEF\xBB\xBF";
diff --git a/base/strings/string_util_posix.h b/base/strings/string_util_posix.h
index 8299118..6868a65 100644
--- a/base/strings/string_util_posix.h
+++ b/base/strings/string_util_posix.h
@@ -21,13 +21,17 @@
return ::strdup(str);
}
-inline int vsnprintf(char* buffer, size_t size,
- const char* format, va_list arguments) {
+inline int vsnprintf(char* buffer,
+ size_t size,
+ const char* format,
+ va_list arguments) {
return ::vsnprintf(buffer, size, format, arguments);
}
-inline int vswprintf(wchar_t* buffer, size_t size,
- const wchar_t* format, va_list 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);
}
diff --git a/base/strings/string_util_win.h b/base/strings/string_util_win.h
index 7f260bf..8f9fa81 100644
--- a/base/strings/string_util_win.h
+++ b/base/strings/string_util_win.h
@@ -21,16 +21,20 @@
return _strdup(str);
}
-inline int vsnprintf(char* buffer, size_t size,
- const char* format, va_list arguments) {
+inline int vsnprintf(char* buffer,
+ size_t size,
+ const char* format,
+ va_list arguments) {
int length = vsnprintf_s(buffer, size, size - 1, format, arguments);
if (length < 0)
return _vscprintf(format, arguments);
return length;
}
-inline int vswprintf(wchar_t* buffer, size_t size,
- const wchar_t* format, va_list arguments) {
+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);
diff --git a/base/strings/stringprintf.cc b/base/strings/stringprintf.cc
index dba4318..a241ee6 100644
--- a/base/strings/stringprintf.cc
+++ b/base/strings/stringprintf.cc
@@ -150,7 +150,8 @@
#if defined(OS_WIN)
const std::wstring& SStringPrintf(std::wstring* dst,
- const wchar_t* format, ...) {
+ const wchar_t* format,
+ ...) {
va_list ap;
va_start(ap, format);
dst->clear();
diff --git a/base/strings/stringprintf.h b/base/strings/stringprintf.h
index e45bef3..9c07862 100644
--- a/base/strings/stringprintf.h
+++ b/base/strings/stringprintf.h
@@ -5,7 +5,7 @@
#ifndef BASE_STRINGS_STRINGPRINTF_H_
#define BASE_STRINGS_STRINGPRINTF_H_
-#include <stdarg.h> // va_list
+#include <stdarg.h> // va_list
#include <string>
@@ -15,13 +15,11 @@
namespace base {
// Return a C++ string given printf-like input.
-std::string StringPrintf(_Printf_format_string_ const char* format,
- ...)
+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;
+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.
@@ -29,25 +27,23 @@
PRINTF_FORMAT(1, 0) WARN_UNUSED_RESULT;
// Store result into a supplied string and return it.
-const std::string& SStringPrintf(
- std::string* dst,
- _Printf_format_string_ const char* format,
- ...) PRINTF_FORMAT(2, 3);
+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);
+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);
+ _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);
+ _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
@@ -55,8 +51,7 @@
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)
+void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap)
WPRINTF_FORMAT(2, 0);
#endif
diff --git a/base/strings/sys_string_conversions.h b/base/strings/sys_string_conversions.h
index 096840b..a13775c 100644
--- a/base/strings/sys_string_conversions.h
+++ b/base/strings/sys_string_conversions.h
@@ -47,8 +47,7 @@
// code page identifier is one accepted by the Windows function
// MultiByteToWideChar().
std::wstring SysMultiByteToWide(StringPiece mb, uint32_t code_page);
-std::string SysWideToMultiByte(const std::wstring& wide,
- uint32_t code_page);
+std::string SysWideToMultiByte(const std::wstring& wide, uint32_t code_page);
#endif // defined(OS_WIN)
diff --git a/base/strings/sys_string_conversions_mac.mm b/base/strings/sys_string_conversions_mac.mm
index 637d941..3b78777 100644
--- a/base/strings/sys_string_conversions_mac.mm
+++ b/base/strings/sys_string_conversions_mac.mm
@@ -21,7 +21,7 @@
// an STL string of the template type. Returns an empty string on failure.
//
// Do not assert in this function since it is used by the asssertion code!
-template<typename StringType>
+template <typename StringType>
static StringType CFStringToSTLStringWithEncodingT(CFStringRef cfstring,
CFStringEncoding encoding) {
CFIndex length = CFStringGetLength(cfstring);
@@ -30,9 +30,7 @@
CFRange whole_string = CFRangeMake(0, length);
CFIndex out_size;
- CFIndex converted = CFStringGetBytes(cfstring,
- whole_string,
- encoding,
+ CFIndex converted = CFStringGetBytes(cfstring, whole_string, encoding,
0, // lossByte
false, // isExternalRepresentation
NULL, // buffer
@@ -50,14 +48,12 @@
out_size * sizeof(UInt8) / sizeof(typename StringType::value_type) + 1;
std::vector<typename StringType::value_type> out_buffer(elements);
- converted = CFStringGetBytes(cfstring,
- whole_string,
- encoding,
- 0, // lossByte
- false, // isExternalRepresentation
- reinterpret_cast<UInt8*>(&out_buffer[0]),
- out_size,
- NULL); // usedBufLen
+ converted =
+ CFStringGetBytes(cfstring, whole_string, encoding,
+ 0, // lossByte
+ false, // isExternalRepresentation
+ reinterpret_cast<UInt8*>(&out_buffer[0]), out_size,
+ NULL); // usedBufLen
if (converted == 0)
return StringType();
@@ -70,7 +66,7 @@
// |OutStringType| template type. Returns an empty string on failure.
//
// Do not assert in this function since it is used by the asssertion code!
-template<typename InStringType, typename OutStringType>
+template <typename InStringType, typename OutStringType>
static OutStringType STLStringToSTLStringWithEncodingsT(
const InStringType& in,
CFStringEncoding in_encoding,
@@ -80,11 +76,8 @@
return OutStringType();
base::ScopedCFTypeRef<CFStringRef> cfstring(CFStringCreateWithBytesNoCopy(
- NULL,
- reinterpret_cast<const UInt8*>(in.data()),
- in_length * sizeof(typename InStringType::value_type),
- in_encoding,
- false,
+ NULL, reinterpret_cast<const UInt8*>(in.data()),
+ in_length * sizeof(typename InStringType::value_type), in_encoding, false,
kCFAllocatorNull));
if (!cfstring)
return OutStringType();
@@ -95,7 +88,7 @@
// Given an STL string |in| with an encoding specified by |in_encoding|,
// return it as a CFStringRef. Returns NULL on failure.
-template<typename StringType>
+template <typename StringType>
static CFStringRef STLStringToCFStringWithEncodingsT(
const StringType& in,
CFStringEncoding in_encoding) {
@@ -103,12 +96,9 @@
if (in_length == 0)
return CFSTR("");
- return CFStringCreateWithBytes(kCFAllocatorDefault,
- reinterpret_cast<const UInt8*>(in.data()),
- in_length *
- sizeof(typename StringType::value_type),
- in_encoding,
- false);
+ return CFStringCreateWithBytes(
+ kCFAllocatorDefault, reinterpret_cast<const UInt8*>(in.data()),
+ in_length * sizeof(typename StringType::value_type), in_encoding, false);
}
// Specify the byte ordering explicitly, otherwise CFString will be confused
@@ -168,8 +158,7 @@
}
string16 SysCFStringRefToUTF16(CFStringRef ref) {
- return CFStringToSTLStringWithEncodingT<string16>(ref,
- kMediumStringEncoding);
+ return CFStringToSTLStringWithEncodingT<string16>(ref, kMediumStringEncoding);
}
std::string SysNSStringToUTF8(NSString* nsstring) {
diff --git a/base/strings/sys_string_conversions_posix.cc b/base/strings/sys_string_conversions_posix.cc
index 97b027a..1a0c685 100644
--- a/base/strings/sys_string_conversions_posix.cc
+++ b/base/strings/sys_string_conversions_posix.cc
@@ -107,7 +107,7 @@
// without writing the output, counting the number of wide characters.
size_t num_out_chars = 0;
memset(&ps, 0, sizeof(ps));
- for (size_t i = 0; i < native_mb.size(); ) {
+ for (size_t i = 0; i < native_mb.size();) {
const char* src = native_mb.data() + i;
size_t res = mbrtowc(nullptr, src, native_mb.size() - i, &ps);
switch (res) {
diff --git a/base/strings/sys_string_conversions_win.cc b/base/strings/sys_string_conversions_win.cc
index 356064f..232dd78 100644
--- a/base/strings/sys_string_conversions_win.cc
+++ b/base/strings/sys_string_conversions_win.cc
@@ -4,8 +4,8 @@
#include "base/strings/sys_string_conversions.h"
-#include <windows.h>
#include <stdint.h>
+#include <windows.h>
#include "base/strings/string_piece.h"
@@ -36,8 +36,8 @@
int mb_length = static_cast<int>(mb.length());
// Compute the length of the buffer.
- int charcount = MultiByteToWideChar(code_page, 0,
- mb.data(), mb_length, NULL, 0);
+ int charcount =
+ MultiByteToWideChar(code_page, 0, mb.data(), mb_length, NULL, 0);
if (charcount == 0)
return std::wstring();
@@ -62,8 +62,8 @@
std::string mb;
mb.resize(charcount);
- WideCharToMultiByte(code_page, 0, wide.data(), wide_length,
- &mb[0], charcount, NULL, NULL);
+ WideCharToMultiByte(code_page, 0, wide.data(), wide_length, &mb[0], charcount,
+ NULL, NULL);
return mb;
}
diff --git a/base/strings/utf_offset_string_conversions.cc b/base/strings/utf_offset_string_conversions.cc
index b91ee03..177839a 100644
--- a/base/strings/utf_offset_string_conversions.cc
+++ b/base/strings/utf_offset_string_conversions.cc
@@ -20,8 +20,7 @@
size_t output_length)
: original_offset(original_offset),
original_length(original_length),
- output_length(output_length) {
-}
+ output_length(output_length) {}
// static
void OffsetAdjuster::AdjustOffsets(const Adjustments& adjustments,
@@ -79,8 +78,7 @@
if (*offset + adjustment <= i->original_offset)
break;
adjustment += static_cast<int>(i->original_length - i->output_length);
- if ((*offset + adjustment) <
- (i->original_offset + i->original_length)) {
+ if ((*offset + adjustment) < (i->original_offset + i->original_length)) {
*offset = string16::npos;
return;
}
@@ -138,8 +136,8 @@
// |adjusted_iter|, then incrementing |adjusted_iter| so it points to
// the following element.
shift += first_iter->original_length - first_iter->output_length;
- adjusted_iter = adjustments_on_adjusted_string->insert(
- adjusted_iter, *first_iter);
+ adjusted_iter =
+ adjustments_on_adjusted_string->insert(adjusted_iter, *first_iter);
++adjusted_iter;
++first_iter;
} else {
@@ -158,7 +156,7 @@
// happened in |first_iter|, then advance to the next |first_adjustments|
// because we dealt with the current one.
const int collapse = static_cast<int>(first_iter->original_length) -
- static_cast<int>(first_iter->output_length);
+ static_cast<int>(first_iter->output_length);
// This function does not know how to deal with a string that expands and
// then gets modified, only strings that collapse and then get modified.
DCHECK_GT(collapse, 0);
@@ -185,7 +183,7 @@
// the result. If non-NULL, |adjustments| is set to reflect the all the
// alterations to the string that are not one-character-to-one-character.
// It will always be sorted by increasing offset.
-template<typename SrcChar, typename DestStdString>
+template <typename SrcChar, typename DestStdString>
bool ConvertUnicode(const SrcChar* src,
size_t src_len,
DestStdString* output,
diff --git a/base/strings/utf_offset_string_conversions.h b/base/strings/utf_offset_string_conversions.h
index fdd012b..b7c4a1b 100644
--- a/base/strings/utf_offset_string_conversions.h
+++ b/base/strings/utf_offset_string_conversions.h
@@ -64,8 +64,7 @@
// Adjusts the single |offset| to reflect the reverse of the adjustments
// recorded in |adjustments|.
- static void UnadjustOffset(const Adjustments& adjustments,
- size_t* offset);
+ static void UnadjustOffset(const Adjustments& adjustments, size_t* offset);
// Combines two sequential sets of adjustments, storing the combined revised
// adjustments in |adjustments_on_adjusted_string|. That is, suppose a
@@ -90,11 +89,10 @@
// Like the conversions in utf_string_conversions.h, but also fills in an
// |adjustments| parameter that reflects the alterations done to the string.
// It may be NULL.
-bool UTF8ToUTF16WithAdjustments(
- const char* src,
- size_t src_len,
- string16* output,
- base::OffsetAdjuster::Adjustments* adjustments);
+bool UTF8ToUTF16WithAdjustments(const char* src,
+ size_t src_len,
+ string16* output,
+ base::OffsetAdjuster::Adjustments* adjustments);
string16 UTF8ToUTF16WithAdjustments(
const base::StringPiece& utf8,
base::OffsetAdjuster::Adjustments* adjustments);
diff --git a/base/strings/utf_string_conversion_utils.cc b/base/strings/utf_string_conversion_utils.cc
index 89f02d5..6098e3a 100644
--- a/base/strings/utf_string_conversion_utils.cc
+++ b/base/strings/utf_string_conversion_utils.cc
@@ -36,15 +36,14 @@
uint32_t* code_point) {
if (CBU16_IS_SURROGATE(src[*char_index])) {
if (!CBU16_IS_SURROGATE_LEAD(src[*char_index]) ||
- *char_index + 1 >= src_len ||
- !CBU16_IS_TRAIL(src[*char_index + 1])) {
+ *char_index + 1 >= src_len || !CBU16_IS_TRAIL(src[*char_index + 1])) {
// Invalid surrogate pair.
return false;
}
// Valid surrogate pair.
- *code_point = CBU16_GET_SUPPLEMENTARY(src[*char_index],
- src[*char_index + 1]);
+ *code_point =
+ CBU16_GET_SUPPLEMENTARY(src[*char_index], src[*char_index + 1]);
(*char_index)++;
} else {
// Not a surrogate, just one 16-bit word.
@@ -76,7 +75,6 @@
return 1;
}
-
// CBU8_APPEND_UNSAFE can append up to 4 bytes.
size_t char_offset = output->length();
size_t original_char_offset = char_offset;
@@ -105,7 +103,7 @@
// Generalized Unicode converter -----------------------------------------------
-template<typename CHAR>
+template <typename CHAR>
void PrepareForUTF8Output(const CHAR* src,
size_t src_len,
std::string* output) {
@@ -128,7 +126,7 @@
#endif
template void PrepareForUTF8Output(const char16*, size_t, std::string*);
-template<typename STRING>
+template <typename STRING>
void PrepareForUTF16Or32Output(const char* src,
size_t src_len,
STRING* output) {
diff --git a/base/strings/utf_string_conversion_utils.h b/base/strings/utf_string_conversion_utils.h
index 1712cee..6f89652 100644
--- a/base/strings/utf_string_conversion_utils.h
+++ b/base/strings/utf_string_conversion_utils.h
@@ -26,9 +26,10 @@
inline bool IsValidCharacter(uint32_t code_point) {
// Excludes non-characters (U+FDD0..U+FDEF, and all codepoints ending in
// 0xFFFE or 0xFFFF) from the set of valid code points.
- return code_point < 0xD800u || (code_point >= 0xE000u &&
- code_point < 0xFDD0u) || (code_point > 0xFDEFu &&
- code_point <= 0x10FFFFu && (code_point & 0xFFFEu) != 0xFFFEu);
+ return code_point < 0xD800u ||
+ (code_point >= 0xE000u && code_point < 0xFDD0u) ||
+ (code_point > 0xFDEFu && code_point <= 0x10FFFFu &&
+ (code_point & 0xFFFEu) != 0xFFFEu);
}
// ReadUnicodeCharacter --------------------------------------------------------
@@ -41,30 +42,29 @@
//
// Returns true on success. On false, |*code_point| will be invalid.
bool ReadUnicodeCharacter(const char* src,
- int32_t src_len,
- int32_t* char_index,
- uint32_t* code_point_out);
+ int32_t src_len,
+ int32_t* char_index,
+ uint32_t* code_point_out);
// Reads a UTF-16 character. The usage is the same as the 8-bit version above.
bool ReadUnicodeCharacter(const char16* src,
- int32_t src_len,
- int32_t* char_index,
- uint32_t* code_point);
+ int32_t src_len,
+ 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);
+ 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
// bytes written.
-size_t WriteUnicodeCharacter(uint32_t code_point,
- std::string* output);
+size_t WriteUnicodeCharacter(uint32_t code_point, std::string* output);
// Appends the given code point as a UTF-16 character to the given 16-bit
// string. Returns the number of 16-bit values written.
@@ -86,12 +86,12 @@
// string, and reserves that amount of space. We assume that the input
// character types are unsigned, which will be true for UTF-16 and -32 on our
// systems.
-template<typename CHAR>
+template <typename CHAR>
void PrepareForUTF8Output(const CHAR* src, size_t src_len, std::string* output);
// Prepares an output buffer (containing either UTF-16 or -32 data) given some
// UTF-8 input that will be converted to it. See PrepareForUTF8Output().
-template<typename STRING>
+template <typename STRING>
void PrepareForUTF16Or32Output(const char* src, size_t src_len, STRING* output);
} // namespace base
diff --git a/base/strings/utf_string_conversions.h b/base/strings/utf_string_conversions.h
index 45a4be3..704943e 100644
--- a/base/strings/utf_string_conversions.h
+++ b/base/strings/utf_string_conversions.h
@@ -20,24 +20,19 @@
// 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);
+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);
+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);
+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);
+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);
+bool UTF16ToUTF8(const char16* src, size_t src_len, std::string* output);
std::string UTF16ToUTF8(StringPiece16 utf16);
// This converts an ASCII string, typically a hardcoded constant, to a UTF16
diff --git a/base/synchronization/condition_variable.h b/base/synchronization/condition_variable.h
index 125bcb1..d778d13 100644
--- a/base/synchronization/condition_variable.h
+++ b/base/synchronization/condition_variable.h
@@ -102,7 +102,6 @@
void Signal();
private:
-
#if defined(OS_WIN)
CHROME_CONDITION_VARIABLE cv_;
CHROME_SRWLOCK* const srwlock_;
diff --git a/base/synchronization/condition_variable_posix.cc b/base/synchronization/condition_variable_posix.cc
index 229b529..7a5ef5f 100644
--- a/base/synchronization/condition_variable_posix.cc
+++ b/base/synchronization/condition_variable_posix.cc
@@ -15,17 +15,16 @@
namespace base {
ConditionVariable::ConditionVariable(Lock* user_lock)
- : user_mutex_(user_lock->lock_.native_handle())
-{
+ : user_mutex_(user_lock->lock_.native_handle()) {
int rv = 0;
- // http://crbug.com/293736
- // NaCl doesn't support monotonic clock based absolute deadlines.
- // On older Android platform versions, it's supported through the
- // non-standard pthread_cond_timedwait_monotonic_np. Newer platform
- // versions have pthread_condattr_setclock.
- // Mac can use relative time deadlines.
+// http://crbug.com/293736
+// NaCl doesn't support monotonic clock based absolute deadlines.
+// On older Android platform versions, it's supported through the
+// non-standard pthread_cond_timedwait_monotonic_np. Newer platform
+// versions have pthread_condattr_setclock.
+// Mac can use relative time deadlines.
#if !defined(OS_MACOSX) && !defined(OS_NACL) && \
- !(defined(OS_ANDROID) && defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC))
+ !(defined(OS_ANDROID) && defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC))
pthread_condattr_t attrs;
rv = pthread_condattr_init(&attrs);
DCHECK_EQ(0, rv);
@@ -70,8 +69,8 @@
(usecs % Time::kMicrosecondsPerSecond) * Time::kNanosecondsPerMicrosecond;
#if defined(OS_MACOSX)
- int rv = pthread_cond_timedwait_relative_np(
- &condition_, user_mutex_, &relative_time);
+ int rv = pthread_cond_timedwait_relative_np(&condition_, user_mutex_,
+ &relative_time);
#else
// The timeout argument to pthread_cond_timedwait is in absolute time.
struct timespec absolute_time;
@@ -87,8 +86,8 @@
DCHECK_GE(absolute_time.tv_sec, now.tv_sec); // Overflow paranoia
#if defined(OS_ANDROID) && defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC)
- int rv = pthread_cond_timedwait_monotonic_np(
- &condition_, user_mutex_, &absolute_time);
+ int rv = pthread_cond_timedwait_monotonic_np(&condition_, user_mutex_,
+ &absolute_time);
#else
int rv = pthread_cond_timedwait(&condition_, user_mutex_, &absolute_time);
#endif // OS_ANDROID && HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC
diff --git a/base/synchronization/condition_variable_win.cc b/base/synchronization/condition_variable_win.cc
index d247e22..87cc353 100644
--- a/base/synchronization/condition_variable_win.cc
+++ b/base/synchronization/condition_variable_win.cc
@@ -12,8 +12,7 @@
namespace base {
ConditionVariable::ConditionVariable(Lock* user_lock)
- : srwlock_(user_lock->lock_.native_handle())
-{
+ : srwlock_(user_lock->lock_.native_handle()) {
DCHECK(user_lock);
InitializeConditionVariable(reinterpret_cast<PCONDITION_VARIABLE>(&cv_));
}
diff --git a/base/synchronization/lock.h b/base/synchronization/lock.h
index 27e493c..98668e9 100644
--- a/base/synchronization/lock.h
+++ b/base/synchronization/lock.h
@@ -17,7 +17,7 @@
// AssertAcquired() method.
class Lock {
public:
- // Optimized wrapper implementation
+ // Optimized wrapper implementation
Lock() : lock_() {}
~Lock() {}
void Acquire() { lock_.Lock(); }
@@ -66,9 +66,7 @@
public:
struct AlreadyAcquired {};
- explicit AutoLock(Lock& lock) : lock_(lock) {
- lock_.Acquire();
- }
+ explicit AutoLock(Lock& lock) : lock_(lock) { lock_.Acquire(); }
AutoLock(Lock& lock, const AlreadyAcquired&) : lock_(lock) {
lock_.AssertAcquired();
@@ -94,9 +92,7 @@
lock_.Release();
}
- ~AutoUnlock() {
- lock_.Acquire();
- }
+ ~AutoUnlock() { lock_.Acquire(); }
private:
Lock& lock_;
diff --git a/base/synchronization/waitable_event.h b/base/synchronization/waitable_event.h
index b4f713d..ee1d33a 100644
--- a/base/synchronization/waitable_event.h
+++ b/base/synchronization/waitable_event.h
@@ -241,8 +241,8 @@
// so we have a kernel of the WaitableEvent, which is reference counted.
// WaitableEventWatchers may then take a reference and thus match the Windows
// behaviour.
- struct WaitableEventKernel :
- public RefCountedThreadSafe<WaitableEventKernel> {
+ struct WaitableEventKernel
+ : public RefCountedThreadSafe<WaitableEventKernel> {
public:
WaitableEventKernel(ResetPolicy reset_policy, InitialState initial_state);
@@ -266,7 +266,8 @@
// second element is the index of the WaitableEvent in the original,
// unsorted, array.
static size_t EnqueueMany(WaiterAndIndex* waitables,
- size_t count, Waiter* waiter);
+ size_t count,
+ Waiter* waiter);
bool SignalAll();
bool SignalOne();
diff --git a/base/synchronization/waitable_event_posix.cc b/base/synchronization/waitable_event_posix.cc
index 3e32686..485038d 100644
--- a/base/synchronization/waitable_event_posix.cc
+++ b/base/synchronization/waitable_event_posix.cc
@@ -107,9 +107,7 @@
return true;
}
- WaitableEvent* signaling_event() const {
- return signaling_event_;
- }
+ WaitableEvent* signaling_event() const { return signaling_event_; }
// ---------------------------------------------------------------------------
// These waiters are always stack allocated and don't delete themselves. Thus
@@ -120,26 +118,18 @@
// ---------------------------------------------------------------------------
// Called with lock held.
// ---------------------------------------------------------------------------
- bool fired() const {
- return fired_;
- }
+ bool fired() const { return fired_; }
// ---------------------------------------------------------------------------
// During a TimedWait, we need a way to make sure that an auto-reset
// WaitableEvent doesn't think that this event has been signaled between
// unlocking it and removing it from the wait-list. Called with lock held.
// ---------------------------------------------------------------------------
- void Disable() {
- fired_ = true;
- }
+ void Disable() { fired_ = true; }
- base::Lock* lock() {
- return &lock_;
- }
+ base::Lock* lock() { return &lock_; }
- base::ConditionVariable* cv() {
- return &cv_;
- }
+ base::ConditionVariable* cv() { return &cv_; }
private:
bool fired_;
@@ -222,20 +212,19 @@
// Synchronous waiting on multiple objects.
static bool // StrictWeakOrdering
-cmp_fst_addr(const std::pair<WaitableEvent*, unsigned> &a,
- const std::pair<WaitableEvent*, unsigned> &b) {
+cmp_fst_addr(const std::pair<WaitableEvent*, unsigned>& a,
+ const std::pair<WaitableEvent*, unsigned>& b) {
return a.first < b.first;
}
// static
-size_t WaitableEvent::WaitMany(WaitableEvent** raw_waitables,
- size_t count) {
+size_t WaitableEvent::WaitMany(WaitableEvent** raw_waitables, size_t count) {
DCHECK(count) << "Cannot wait on no events";
// We need to acquire the locks in a globally consistent order. Thus we sort
// the array of waitables by address. We actually sort a pairs so that we can
// map back to the original index values later.
- std::vector<std::pair<WaitableEvent*, size_t> > waitables;
+ std::vector<std::pair<WaitableEvent*, size_t>> waitables;
waitables.reserve(count);
for (size_t i = 0; i < count; ++i)
waitables.push_back(std::make_pair(raw_waitables[i], i));
@@ -248,7 +237,7 @@
// address, we can check this cheaply by comparing pairs of consecutive
// elements.
for (size_t i = 0; i < waitables.size() - 1; ++i) {
- DCHECK(waitables[i].first != waitables[i+1].first);
+ DCHECK(waitables[i].first != waitables[i + 1].first);
}
SyncWaiter sw;
@@ -263,21 +252,21 @@
// At this point, we hold the locks on all the WaitableEvents and we have
// enqueued our waiter in them all.
sw.lock()->Acquire();
- // Release the WaitableEvent locks in the reverse order
- for (size_t i = 0; i < count; ++i) {
- waitables[count - (1 + i)].first->kernel_->lock_.Release();
- }
+ // Release the WaitableEvent locks in the reverse order
+ for (size_t i = 0; i < count; ++i) {
+ waitables[count - (1 + i)].first->kernel_->lock_.Release();
+ }
- for (;;) {
- if (sw.fired())
- break;
+ for (;;) {
+ if (sw.fired())
+ break;
- sw.cv()->Wait();
- }
+ sw.cv()->Wait();
+ }
sw.lock()->Release();
// The address of the WaitableEvent which fired is stored in the SyncWaiter.
- WaitableEvent *const signaled_event = sw.signaling_event();
+ WaitableEvent* const signaled_event = sw.signaling_event();
// This will store the index of the raw_waitables which fired.
size_t signaled_index = 0;
@@ -286,10 +275,10 @@
for (size_t i = 0; i < count; ++i) {
if (raw_waitables[i] != signaled_event) {
raw_waitables[i]->kernel_->lock_.Acquire();
- // There's no possible ABA issue with the address of the SyncWaiter here
- // because it lives on the stack. Thus the tag value is just the pointer
- // value again.
- raw_waitables[i]->kernel_->Dequeue(&sw, &sw);
+ // There's no possible ABA issue with the address of the SyncWaiter here
+ // because it lives on the stack. Thus the tag value is just the pointer
+ // value again.
+ raw_waitables[i]->kernel_->Dequeue(&sw, &sw);
raw_waitables[i]->kernel_->lock_.Release();
} else {
// By taking this lock here we ensure that |Signal| has completed by the
@@ -353,7 +342,6 @@
// -----------------------------------------------------------------------------
-
// -----------------------------------------------------------------------------
// Private functions...
@@ -371,8 +359,8 @@
bool WaitableEvent::SignalAll() {
bool signaled_at_least_one = false;
- for (std::list<Waiter*>::iterator
- i = kernel_->waiters_.begin(); i != kernel_->waiters_.end(); ++i) {
+ for (std::list<Waiter*>::iterator i = kernel_->waiters_.begin();
+ i != kernel_->waiters_.end(); ++i) {
if ((*i)->Fire(this))
signaled_at_least_one = true;
}
@@ -409,8 +397,8 @@
// actually removed. Called with lock held.
// -----------------------------------------------------------------------------
bool WaitableEvent::WaitableEventKernel::Dequeue(Waiter* waiter, void* tag) {
- for (std::list<Waiter*>::iterator
- i = waiters_.begin(); i != waiters_.end(); ++i) {
+ for (std::list<Waiter*>::iterator i = waiters_.begin(); i != waiters_.end();
+ ++i) {
if (*i == waiter && (*i)->Compare(tag)) {
waiters_.erase(i);
return true;
diff --git a/base/synchronization/waitable_event_win.cc b/base/synchronization/waitable_event_win.cc
index 15dd10a..1301840 100644
--- a/base/synchronization/waitable_event_win.cc
+++ b/base/synchronization/waitable_event_win.cc
@@ -4,8 +4,8 @@
#include "base/synchronization/waitable_event.h"
-#include <windows.h>
#include <stddef.h>
+#include <windows.h>
#include <algorithm>
#include <utility>
@@ -127,8 +127,7 @@
// The cast is safe because count is small - see the CHECK above.
DWORD result =
- WaitForMultipleObjects(static_cast<DWORD>(count),
- handles,
+ WaitForMultipleObjects(static_cast<DWORD>(count), handles,
FALSE, // don't wait for all the objects
INFINITE); // no timeout
if (result >= WAIT_OBJECT_0 + count) {
diff --git a/base/template_util.h b/base/template_util.h
index 11e7ba8..e92be91 100644
--- a/base/template_util.h
+++ b/base/template_util.h
@@ -38,9 +38,12 @@
namespace base {
-template <class T> struct is_non_const_reference : std::false_type {};
-template <class T> struct is_non_const_reference<T&> : std::true_type {};
-template <class T> struct is_non_const_reference<const T&> : std::false_type {};
+template <class T>
+struct is_non_const_reference : std::false_type {};
+template <class T>
+struct is_non_const_reference<T&> : std::true_type {};
+template <class T>
+struct is_non_const_reference<const T&> : std::false_type {};
namespace internal {
diff --git a/base/third_party/icu/icu_utf.cc b/base/third_party/icu/icu_utf.cc
index a3262b0..8dcb401 100644
--- a/base/third_party/icu/icu_utf.cc
+++ b/base/third_party/icu/icu_utf.cc
@@ -25,23 +25,19 @@
// source/common/utf_impl.cpp
-static const UChar32
-utf8_errorValue[6]={
+static const UChar32 utf8_errorValue[6] = {
// Same values as UTF8_ERROR_VALUE_1, UTF8_ERROR_VALUE_2, UTF_ERROR_VALUE,
// but without relying on the obsolete unicode/utf_old.h.
- 0x15, 0x9f, 0xffff,
- 0x10ffff
-};
+ 0x15, 0x9f, 0xffff, 0x10ffff};
-static UChar32
-errorValue(int32_t count, int8_t strict) {
- if(strict>=0) {
- return utf8_errorValue[count];
- } else if(strict==-3) {
- return 0xfffd;
- } else {
- return CBU_SENTINEL;
- }
+static UChar32 errorValue(int32_t count, int8_t strict) {
+ if (strict >= 0) {
+ return utf8_errorValue[count];
+ } else if (strict == -3) {
+ return 0xfffd;
+ } else {
+ return CBU_SENTINEL;
+ }
}
/*
@@ -53,79 +49,81 @@
* The "strict" parameter controls the error behavior:
* <0 "Safe" behavior of U8_NEXT():
* -1: All illegal byte sequences yield U_SENTINEL=-1.
- * -2: Same as -1, except for lenient treatment of surrogate code points as legal.
- * Some implementations use this for roundtripping of
- * Unicode 16-bit strings that are not well-formed UTF-16, that is, they
- * contain unpaired surrogates.
- * -3: All illegal byte sequences yield U+FFFD.
- * 0 Obsolete "safe" behavior of UTF8_NEXT_CHAR_SAFE(..., FALSE):
- * All illegal byte sequences yield a positive code point such that this
- * result code point would be encoded with the same number of bytes as
- * the illegal sequence.
- * >0 Obsolete "strict" behavior of UTF8_NEXT_CHAR_SAFE(..., TRUE):
- * Same as the obsolete "safe" behavior, but non-characters are also treated
- * like illegal sequences.
+ * -2: Same as -1, except for lenient treatment of surrogate code points as
+ * legal. Some implementations use this for roundtripping of Unicode 16-bit
+ * strings that are not well-formed UTF-16, that is, they contain
+ * unpaired surrogates. -3: All illegal byte sequences yield U+FFFD. 0
+ * Obsolete "safe" behavior of UTF8_NEXT_CHAR_SAFE(..., FALSE): All illegal
+ * byte sequences yield a positive code point such that this result code
+ * point would be encoded with the same number of bytes as the illegal
+ * sequence. >0 Obsolete "strict" behavior of UTF8_NEXT_CHAR_SAFE(...,
+ * TRUE): Same as the obsolete "safe" behavior, but non-characters are also
+ * treated like illegal sequences.
*
* Note that a UBool is the same as an int8_t.
*/
-UChar32
-utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, UChar32 c, UBool strict) {
- // *pi is one after byte c.
- int32_t i=*pi;
- // length can be negative for NUL-terminated strings: Read and validate one byte at a time.
- if(i==length || c>0xf4) {
- // end of string, or not a lead byte
- } else if(c>=0xf0) {
- // Test for 4-byte sequences first because
- // U8_NEXT() handles shorter valid sequences inline.
- uint8_t t1=s[i], t2, t3;
- c&=7;
- if(CBU8_IS_VALID_LEAD4_AND_T1(c, t1) &&
- ++i!=length && (t2=s[i]-0x80)<=0x3f &&
- ++i!=length && (t3=s[i]-0x80)<=0x3f) {
- ++i;
- c=(c<<18)|((t1&0x3f)<<12)|(t2<<6)|t3;
- // strict: forbid non-characters like U+fffe
- if(strict<=0 || !CBU_IS_UNICODE_NONCHAR(c)) {
- *pi=i;
- return c;
- }
+UChar32 utf8_nextCharSafeBody(const uint8_t* s,
+ int32_t* pi,
+ int32_t length,
+ UChar32 c,
+ UBool strict) {
+ // *pi is one after byte c.
+ int32_t i = *pi;
+ // length can be negative for NUL-terminated strings: Read and validate one
+ // byte at a time.
+ if (i == length || c > 0xf4) {
+ // end of string, or not a lead byte
+ } else if (c >= 0xf0) {
+ // Test for 4-byte sequences first because
+ // U8_NEXT() handles shorter valid sequences inline.
+ uint8_t t1 = s[i], t2, t3;
+ c &= 7;
+ if (CBU8_IS_VALID_LEAD4_AND_T1(c, t1) && ++i != length &&
+ (t2 = s[i] - 0x80) <= 0x3f && ++i != length &&
+ (t3 = s[i] - 0x80) <= 0x3f) {
+ ++i;
+ c = (c << 18) | ((t1 & 0x3f) << 12) | (t2 << 6) | t3;
+ // strict: forbid non-characters like U+fffe
+ if (strict <= 0 || !CBU_IS_UNICODE_NONCHAR(c)) {
+ *pi = i;
+ return c;
+ }
+ }
+ } else if (c >= 0xe0) {
+ c &= 0xf;
+ if (strict != -2) {
+ uint8_t t1 = s[i], t2;
+ if (CBU8_IS_VALID_LEAD3_AND_T1(c, t1) && ++i != length &&
+ (t2 = s[i] - 0x80) <= 0x3f) {
+ ++i;
+ c = (c << 12) | ((t1 & 0x3f) << 6) | t2;
+ // strict: forbid non-characters like U+fffe
+ if (strict <= 0 || !CBU_IS_UNICODE_NONCHAR(c)) {
+ *pi = i;
+ return c;
}
- } else if(c>=0xe0) {
- c&=0xf;
- if(strict!=-2) {
- uint8_t t1=s[i], t2;
- if(CBU8_IS_VALID_LEAD3_AND_T1(c, t1) &&
- ++i!=length && (t2=s[i]-0x80)<=0x3f) {
- ++i;
- c=(c<<12)|((t1&0x3f)<<6)|t2;
- // strict: forbid non-characters like U+fffe
- if(strict<=0 || !CBU_IS_UNICODE_NONCHAR(c)) {
- *pi=i;
- return c;
- }
- }
- } else {
- // strict=-2 -> lenient: allow surrogates
- uint8_t t1=s[i]-0x80, t2;
- if(t1<=0x3f && (c>0 || t1>=0x20) &&
- ++i!=length && (t2=s[i]-0x80)<=0x3f) {
- *pi=i+1;
- return (c<<12)|(t1<<6)|t2;
- }
- }
- } else if(c>=0xc2) {
- uint8_t t1=s[i]-0x80;
- if(t1<=0x3f) {
- *pi=i+1;
- return ((c-0xc0)<<6)|t1;
- }
- } // else 0x80<=c<0xc2 is not a lead byte
+ }
+ } else {
+ // strict=-2 -> lenient: allow surrogates
+ uint8_t t1 = s[i] - 0x80, t2;
+ if (t1 <= 0x3f && (c > 0 || t1 >= 0x20) && ++i != length &&
+ (t2 = s[i] - 0x80) <= 0x3f) {
+ *pi = i + 1;
+ return (c << 12) | (t1 << 6) | t2;
+ }
+ }
+ } else if (c >= 0xc2) {
+ uint8_t t1 = s[i] - 0x80;
+ if (t1 <= 0x3f) {
+ *pi = i + 1;
+ return ((c - 0xc0) << 6) | t1;
+ }
+ } // else 0x80<=c<0xc2 is not a lead byte
- /* error handling */
- c=errorValue(i-*pi, strict);
- *pi=i;
- return c;
+ /* error handling */
+ c = errorValue(i - *pi, strict);
+ *pi = i;
+ return c;
}
} // namespace base_icu
diff --git a/base/third_party/icu/icu_utf.h b/base/third_party/icu/icu_utf.h
index 2ba8231..b626b39 100644
--- a/base/third_party/icu/icu_utf.h
+++ b/base/third_party/icu/icu_utf.h
@@ -68,9 +68,9 @@
* @return TRUE or FALSE
* @stable ICU 2.4
*/
-#define CBU_IS_UNICODE_NONCHAR(c) \
- ((c)>=0xfdd0 && \
- ((c)<=0xfdef || ((c)&0xfffe)==0xfffe) && (c)<=0x10ffff)
+#define CBU_IS_UNICODE_NONCHAR(c) \
+ ((c) >= 0xfdd0 && ((c) <= 0xfdef || ((c)&0xfffe) == 0xfffe) && \
+ (c) <= 0x10ffff)
/**
* Is c a Unicode code point value (0..U+10ffff)
@@ -78,9 +78,9 @@
*
* Code points that are not characters include:
* - single surrogate code points (U+d800..U+dfff, 2048 code points)
- * - the last two code points on each plane (U+__fffe and U+__ffff, 34 code points)
- * - U+fdd0..U+fdef (new with Unicode 3.1, 32 code points)
- * - the highest Unicode code point value is U+10ffff
+ * - the last two code points on each plane (U+__fffe and U+__ffff, 34 code
+ * points) - U+fdd0..U+fdef (new with Unicode 3.1, 32 code points) - the highest
+ * Unicode code point value is U+10ffff
*
* This means that all code points below U+d800 are character code points,
* and that boundary is tested first for performance.
@@ -90,8 +90,8 @@
* @stable ICU 2.4
*/
#define CBU_IS_UNICODE_CHAR(c) \
- ((uint32_t)(c)<0xd800 || \
- (0xdfff<(c) && (c)<=0x10ffff && !CBU_IS_UNICODE_NONCHAR(c)))
+ ((uint32_t)(c) < 0xd800 || \
+ (0xdfff < (c) && (c) <= 0x10ffff && !CBU_IS_UNICODE_NONCHAR(c)))
/**
* Is this code point a surrogate (U+d800..U+dfff)?
@@ -99,7 +99,7 @@
* @return TRUE or FALSE
* @stable ICU 2.4
*/
-#define CBU_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800)
+#define CBU_IS_SURROGATE(c) (((c)&0xfffff800) == 0xd800)
/**
* Assuming c is a surrogate code point (U_IS_SURROGATE(c)),
@@ -108,43 +108,51 @@
* @return TRUE or FALSE
* @stable ICU 2.4
*/
-#define CBU_IS_SURROGATE_LEAD(c) (((c)&0x400)==0)
+#define CBU_IS_SURROGATE_LEAD(c) (((c)&0x400) == 0)
// source/common/unicode/utf8.h
/**
- * Internal bit vector for 3-byte UTF-8 validity check, for use in U8_IS_VALID_LEAD3_AND_T1.
- * Each bit indicates whether one lead byte + first trail byte pair starts a valid sequence.
- * Lead byte E0..EF bits 3..0 are used as byte index,
- * first trail byte bits 7..5 are used as bit index into that byte.
+ * Internal bit vector for 3-byte UTF-8 validity check, for use in
+ * U8_IS_VALID_LEAD3_AND_T1. Each bit indicates whether one lead byte + first
+ * trail byte pair starts a valid sequence. Lead byte E0..EF bits 3..0 are used
+ * as byte index, first trail byte bits 7..5 are used as bit index into that
+ * byte.
* @see U8_IS_VALID_LEAD3_AND_T1
* @internal
*/
-#define CBU8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30"
+#define CBU8_LEAD3_T1_BITS \
+ "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30"
/**
* Internal 3-byte UTF-8 validity check.
- * Non-zero if lead byte E0..EF and first trail byte 00..FF start a valid sequence.
+ * Non-zero if lead byte E0..EF and first trail byte 00..FF start a valid
+ * sequence.
* @internal
*/
-#define CBU8_IS_VALID_LEAD3_AND_T1(lead, t1) (CBU8_LEAD3_T1_BITS[(lead)&0xf]&(1<<((uint8_t)(t1)>>5)))
+#define CBU8_IS_VALID_LEAD3_AND_T1(lead, t1) \
+ (CBU8_LEAD3_T1_BITS[(lead)&0xf] & (1 << ((uint8_t)(t1) >> 5)))
/**
- * Internal bit vector for 4-byte UTF-8 validity check, for use in U8_IS_VALID_LEAD4_AND_T1.
- * Each bit indicates whether one lead byte + first trail byte pair starts a valid sequence.
- * First trail byte bits 7..4 are used as byte index,
- * lead byte F0..F4 bits 2..0 are used as bit index into that byte.
+ * Internal bit vector for 4-byte UTF-8 validity check, for use in
+ * U8_IS_VALID_LEAD4_AND_T1. Each bit indicates whether one lead byte + first
+ * trail byte pair starts a valid sequence. First trail byte bits 7..4 are used
+ * as byte index, lead byte F0..F4 bits 2..0 are used as bit index into that
+ * byte.
* @see U8_IS_VALID_LEAD4_AND_T1
* @internal
*/
-#define CBU8_LEAD4_T1_BITS "\x00\x00\x00\x00\x00\x00\x00\x00\x1E\x0F\x0F\x0F\x00\x00\x00\x00"
+#define CBU8_LEAD4_T1_BITS \
+ "\x00\x00\x00\x00\x00\x00\x00\x00\x1E\x0F\x0F\x0F\x00\x00\x00\x00"
/**
* Internal 4-byte UTF-8 validity check.
- * Non-zero if lead byte F0..F4 and first trail byte 00..FF start a valid sequence.
+ * Non-zero if lead byte F0..F4 and first trail byte 00..FF start a valid
+ * sequence.
* @internal
*/
-#define CBU8_IS_VALID_LEAD4_AND_T1(lead, t1) (CBU8_LEAD4_T1_BITS[(uint8_t)(t1)>>4]&(1<<((lead)&7)))
+#define CBU8_IS_VALID_LEAD4_AND_T1(lead, t1) \
+ (CBU8_LEAD4_T1_BITS[(uint8_t)(t1) >> 4] & (1 << ((lead)&7)))
/**
* Function for handling "next code point" with error-checking.
@@ -158,8 +166,11 @@
* functions are hidden (otherwise public macros would fail to compile).
* @internal
*/
-UChar32
-utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, ::base_icu::UChar32 c, ::base_icu::UBool strict);
+UChar32 utf8_nextCharSafeBody(const uint8_t* s,
+ int32_t* pi,
+ int32_t length,
+ ::base_icu::UChar32 c,
+ ::base_icu::UBool strict);
/**
* Does this code unit (byte) encode a code point by itself (US-ASCII 0..0x7f)?
@@ -167,7 +178,7 @@
* @return TRUE or FALSE
* @stable ICU 2.4
*/
-#define CBU8_IS_SINGLE(c) (((c)&0x80)==0)
+#define CBU8_IS_SINGLE(c) (((c)&0x80) == 0)
/**
* Is this code unit (byte) a UTF-8 lead byte? (0xC2..0xF4)
@@ -175,7 +186,7 @@
* @return TRUE or FALSE
* @stable ICU 2.4
*/
-#define CBU8_IS_LEAD(c) ((uint8_t)((c)-0xc2)<=0x32)
+#define CBU8_IS_LEAD(c) ((uint8_t)((c)-0xc2) <= 0x32)
/**
* Is this code unit (byte) a UTF-8 trail byte? (0x80..0xBF)
@@ -183,7 +194,7 @@
* @return TRUE or FALSE
* @stable ICU 2.4
*/
-#define CBU8_IS_TRAIL(c) ((int8_t)(c)<-0x40)
+#define CBU8_IS_TRAIL(c) ((int8_t)(c) < -0x40)
/**
* How many code units (bytes) are used for the UTF-8 encoding
@@ -192,19 +203,20 @@
* @return 1..4, or 0 if c is a surrogate or not a Unicode code point
* @stable ICU 2.4
*/
-#define CBU8_LENGTH(c) \
- ((uint32_t)(c)<=0x7f ? 1 : \
- ((uint32_t)(c)<=0x7ff ? 2 : \
- ((uint32_t)(c)<=0xd7ff ? 3 : \
- ((uint32_t)(c)<=0xdfff || (uint32_t)(c)>0x10ffff ? 0 : \
- ((uint32_t)(c)<=0xffff ? 3 : 4)\
- ) \
- ) \
- ) \
- )
+#define CBU8_LENGTH(c) \
+ ((uint32_t)(c) <= 0x7f \
+ ? 1 \
+ : ((uint32_t)(c) <= 0x7ff \
+ ? 2 \
+ : ((uint32_t)(c) <= 0xd7ff \
+ ? 3 \
+ : ((uint32_t)(c) <= 0xdfff || (uint32_t)(c) > 0x10ffff \
+ ? 0 \
+ : ((uint32_t)(c) <= 0xffff ? 3 : 4)))))
/**
- * The maximum number of UTF-8 code units (bytes) per Unicode code point (U+0000..U+10ffff).
+ * The maximum number of UTF-8 code units (bytes) per Unicode code point
+ * (U+0000..U+10ffff).
* @return 4
* @stable ICU 2.4
*/
@@ -230,36 +242,37 @@
* @see U8_NEXT_UNSAFE
* @stable ICU 2.4
*/
-#define CBU8_NEXT(s, i, length, c) { \
- (c)=(uint8_t)(s)[(i)++]; \
- if(!CBU8_IS_SINGLE(c)) { \
- uint8_t __t1, __t2; \
- if( /* handle U+0800..U+FFFF inline */ \
- (0xe0<=(c) && (c)<0xf0) && \
- (((i)+1)<(length) || (length)<0) && \
- CBU8_IS_VALID_LEAD3_AND_T1((c), __t1=(s)[i]) && \
- (__t2=(s)[(i)+1]-0x80)<=0x3f) { \
- (c)=(((c)&0xf)<<12)|((__t1&0x3f)<<6)|__t2; \
- (i)+=2; \
- } else if( /* handle U+0080..U+07FF inline */ \
- ((c)<0xe0 && (c)>=0xc2) && \
- ((i)!=(length)) && \
- (__t1=(s)[i]-0x80)<=0x3f) { \
- (c)=(((c)&0x1f)<<6)|__t1; \
- ++(i); \
- } else { \
- /* function call for "complicated" and error cases */ \
- (c)=::base_icu::utf8_nextCharSafeBody((const uint8_t *)s, &(i), (length), c, -1); \
- } \
- } \
-}
+#define CBU8_NEXT(s, i, length, c) \
+ { \
+ (c) = (uint8_t)(s)[(i)++]; \
+ if (!CBU8_IS_SINGLE(c)) { \
+ uint8_t __t1, __t2; \
+ if (/* handle U+0800..U+FFFF inline */ \
+ (0xe0 <= (c) && (c) < 0xf0) && \
+ (((i) + 1) < (length) || (length) < 0) && \
+ CBU8_IS_VALID_LEAD3_AND_T1((c), __t1 = (s)[i]) && \
+ (__t2 = (s)[(i) + 1] - 0x80) <= 0x3f) { \
+ (c) = (((c)&0xf) << 12) | ((__t1 & 0x3f) << 6) | __t2; \
+ (i) += 2; \
+ } else if (/* handle U+0080..U+07FF inline */ \
+ ((c) < 0xe0 && (c) >= 0xc2) && ((i) != (length)) && \
+ (__t1 = (s)[i] - 0x80) <= 0x3f) { \
+ (c) = (((c)&0x1f) << 6) | __t1; \
+ ++(i); \
+ } else { \
+ /* function call for "complicated" and error cases */ \
+ (c) = ::base_icu::utf8_nextCharSafeBody((const uint8_t*)s, &(i), \
+ (length), c, -1); \
+ } \
+ } \
+ }
/**
* Append a code point to a string, overwriting 1 to 4 bytes.
* The offset points to the current end of the string contents
* and is advanced (post-increment).
- * "Unsafe" macro, assumes a valid code point and sufficient space in the string.
- * Otherwise, the result is undefined.
+ * "Unsafe" macro, assumes a valid code point and sufficient space in the
+ * string. Otherwise, the result is undefined.
*
* @param s const uint8_t * string buffer
* @param i string offset
@@ -267,24 +280,25 @@
* @see U8_APPEND
* @stable ICU 2.4
*/
-#define CBU8_APPEND_UNSAFE(s, i, c) { \
- if((uint32_t)(c)<=0x7f) { \
- (s)[(i)++]=(uint8_t)(c); \
- } else { \
- if((uint32_t)(c)<=0x7ff) { \
- (s)[(i)++]=(uint8_t)(((c)>>6)|0xc0); \
- } else { \
- if((uint32_t)(c)<=0xffff) { \
- (s)[(i)++]=(uint8_t)(((c)>>12)|0xe0); \
- } else { \
- (s)[(i)++]=(uint8_t)(((c)>>18)|0xf0); \
- (s)[(i)++]=(uint8_t)((((c)>>12)&0x3f)|0x80); \
- } \
- (s)[(i)++]=(uint8_t)((((c)>>6)&0x3f)|0x80); \
- } \
- (s)[(i)++]=(uint8_t)(((c)&0x3f)|0x80); \
- } \
-}
+#define CBU8_APPEND_UNSAFE(s, i, c) \
+ { \
+ if ((uint32_t)(c) <= 0x7f) { \
+ (s)[(i)++] = (uint8_t)(c); \
+ } else { \
+ if ((uint32_t)(c) <= 0x7ff) { \
+ (s)[(i)++] = (uint8_t)(((c) >> 6) | 0xc0); \
+ } else { \
+ if ((uint32_t)(c) <= 0xffff) { \
+ (s)[(i)++] = (uint8_t)(((c) >> 12) | 0xe0); \
+ } else { \
+ (s)[(i)++] = (uint8_t)(((c) >> 18) | 0xf0); \
+ (s)[(i)++] = (uint8_t)((((c) >> 12) & 0x3f) | 0x80); \
+ } \
+ (s)[(i)++] = (uint8_t)((((c) >> 6) & 0x3f) | 0x80); \
+ } \
+ (s)[(i)++] = (uint8_t)(((c)&0x3f) | 0x80); \
+ } \
+ }
// source/common/unicode/utf16.h
@@ -302,7 +316,7 @@
* @return TRUE or FALSE
* @stable ICU 2.4
*/
-#define CBU16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800)
+#define CBU16_IS_LEAD(c) (((c)&0xfffffc00) == 0xd800)
/**
* Is this code unit a trail surrogate (U+dc00..U+dfff)?
@@ -310,7 +324,7 @@
* @return TRUE or FALSE
* @stable ICU 2.4
*/
-#define CBU16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00)
+#define CBU16_IS_TRAIL(c) (((c)&0xfffffc00) == 0xdc00)
/**
* Is this code unit a surrogate (U+d800..U+dfff)?
@@ -327,13 +341,13 @@
* @return TRUE or FALSE
* @stable ICU 2.4
*/
-#define CBU16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0)
+#define CBU16_IS_SURROGATE_LEAD(c) (((c)&0x400) == 0)
/**
* Helper constant for U16_GET_SUPPLEMENTARY.
* @internal
*/
-#define CBU16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000)
+#define CBU16_SURROGATE_OFFSET ((0xd800 << 10UL) + 0xdc00 - 0x10000)
/**
* Get a supplementary code point value (U+10000..U+10ffff)
@@ -347,7 +361,8 @@
* @stable ICU 2.4
*/
#define CBU16_GET_SUPPLEMENTARY(lead, trail) \
- (((::base_icu::UChar32)(lead)<<10UL)+(::base_icu::UChar32)(trail)-CBU16_SURROGATE_OFFSET)
+ (((::base_icu::UChar32)(lead) << 10UL) + \
+ (::base_icu::UChar32)(trail)-CBU16_SURROGATE_OFFSET)
/**
* Get the lead surrogate (0xd800..0xdbff) for a
@@ -356,7 +371,8 @@
* @return lead surrogate (U+d800..U+dbff) for supplementary
* @stable ICU 2.4
*/
-#define CBU16_LEAD(supplementary) (::base_icu::UChar)(((supplementary)>>10)+0xd7c0)
+#define CBU16_LEAD(supplementary) \
+ (::base_icu::UChar)(((supplementary) >> 10) + 0xd7c0)
/**
* Get the trail surrogate (0xdc00..0xdfff) for a
@@ -365,19 +381,22 @@
* @return trail surrogate (U+dc00..U+dfff) for supplementary
* @stable ICU 2.4
*/
-#define CBU16_TRAIL(supplementary) (::base_icu::UChar)(((supplementary)&0x3ff)|0xdc00)
+#define CBU16_TRAIL(supplementary) \
+ (::base_icu::UChar)(((supplementary)&0x3ff) | 0xdc00)
/**
- * How many 16-bit code units are used to encode this Unicode code point? (1 or 2)
- * The result is not defined if c is not a Unicode code point (U+0000..U+10ffff).
+ * How many 16-bit code units are used to encode this Unicode code point? (1 or
+ * 2) The result is not defined if c is not a Unicode code point
+ * (U+0000..U+10ffff).
* @param c 32-bit code point
* @return 1 or 2
* @stable ICU 2.4
*/
-#define CBU16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2)
+#define CBU16_LENGTH(c) ((uint32_t)(c) <= 0xffff ? 1 : 2)
/**
- * The maximum number of 16-bit code units per Unicode code point (U+0000..U+10ffff).
+ * The maximum number of 16-bit code units per Unicode code point
+ * (U+0000..U+10ffff).
* @return 2
* @stable ICU 2.4
*/
@@ -395,7 +414,8 @@
* for a supplementary code point, in which case the macro will read
* the following trail surrogate as well.
* If the offset points to a trail surrogate or
- * to a single, unpaired lead surrogate, then c is set to that unpaired surrogate.
+ * to a single, unpaired lead surrogate, then c is set to that unpaired
+ * surrogate.
*
* @param s const UChar * string
* @param i string offset, must be i<length
@@ -404,23 +424,24 @@
* @see U16_NEXT_UNSAFE
* @stable ICU 2.4
*/
-#define CBU16_NEXT(s, i, length, c) { \
- (c)=(s)[(i)++]; \
- if(CBU16_IS_LEAD(c)) { \
- uint16_t __c2; \
- if((i)!=(length) && CBU16_IS_TRAIL(__c2=(s)[(i)])) { \
- ++(i); \
- (c)=CBU16_GET_SUPPLEMENTARY((c), __c2); \
- } \
- } \
-}
+#define CBU16_NEXT(s, i, length, c) \
+ { \
+ (c) = (s)[(i)++]; \
+ if (CBU16_IS_LEAD(c)) { \
+ uint16_t __c2; \
+ if ((i) != (length) && CBU16_IS_TRAIL(__c2 = (s)[(i)])) { \
+ ++(i); \
+ (c) = CBU16_GET_SUPPLEMENTARY((c), __c2); \
+ } \
+ } \
+ }
/**
* Append a code point to a string, overwriting 1 or 2 code units.
* The offset points to the current end of the string contents
* and is advanced (post-increment).
- * "Unsafe" macro, assumes a valid code point and sufficient space in the string.
- * Otherwise, the result is undefined.
+ * "Unsafe" macro, assumes a valid code point and sufficient space in the
+ * string. Otherwise, the result is undefined.
*
* @param s const UChar * string buffer
* @param i string offset
@@ -428,15 +449,16 @@
* @see U16_APPEND
* @stable ICU 2.4
*/
-#define CBU16_APPEND_UNSAFE(s, i, c) { \
- if((uint32_t)(c)<=0xffff) { \
- (s)[(i)++]=(uint16_t)(c); \
- } else { \
- (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \
- (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \
- } \
-}
+#define CBU16_APPEND_UNSAFE(s, i, c) \
+ { \
+ if ((uint32_t)(c) <= 0xffff) { \
+ (s)[(i)++] = (uint16_t)(c); \
+ } else { \
+ (s)[(i)++] = (uint16_t)(((c) >> 10) + 0xd7c0); \
+ (s)[(i)++] = (uint16_t)(((c)&0x3ff) | 0xdc00); \
+ } \
+ }
-} // namesapce base_icu
+} // namespace base_icu
#endif // BASE_THIRD_PARTY_ICU_ICU_UTF_H_
diff --git a/base/threading/platform_thread.h b/base/threading/platform_thread.h
index 6fbe327..3f1cc75 100644
--- a/base/threading/platform_thread.h
+++ b/base/threading/platform_thread.h
@@ -54,15 +54,12 @@
explicit constexpr PlatformThreadRef(RefType id) : id_(id) {}
- bool operator==(PlatformThreadRef other) const {
- return id_ == other.id_;
- }
+ bool operator==(PlatformThreadRef other) const { return id_ == other.id_; }
bool operator!=(PlatformThreadRef other) const { return id_ != other.id_; }
- bool is_null() const {
- return id_ == 0;
- }
+ bool is_null() const { return id_ == 0; }
+
private:
RefType id_;
};
@@ -84,13 +81,9 @@
return handle_ == other.handle_;
}
- bool is_null() const {
- return !handle_;
- }
+ bool is_null() const { return !handle_; }
- Handle platform_handle() const {
- return handle_;
- }
+ Handle platform_handle() const { return handle_; }
private:
Handle handle_;
diff --git a/base/threading/platform_thread_mac.mm b/base/threading/platform_thread_mac.mm
index 8174dba..2a7cd48 100644
--- a/base/threading/platform_thread_mac.mm
+++ b/base/threading/platform_thread_mac.mm
@@ -71,16 +71,14 @@
if (pthread_attr_getstacksize(&attributes, &default_stack_size) == 0 &&
getrlimit(RLIMIT_STACK, &stack_rlimit) == 0 &&
stack_rlimit.rlim_cur != RLIM_INFINITY) {
- default_stack_size =
- std::max(std::max(default_stack_size,
- static_cast<size_t>(PTHREAD_STACK_MIN)),
- static_cast<size_t>(stack_rlimit.rlim_cur));
+ default_stack_size = std::max(
+ std::max(default_stack_size, static_cast<size_t>(PTHREAD_STACK_MIN)),
+ static_cast<size_t>(stack_rlimit.rlim_cur));
}
return default_stack_size;
#endif
}
-void TerminateOnThread() {
-}
+void TerminateOnThread() {}
} // namespace base
diff --git a/base/threading/platform_thread_posix.cc b/base/threading/platform_thread_posix.cc
index 32a052a..bfec23c 100644
--- a/base/threading/platform_thread_posix.cc
+++ b/base/threading/platform_thread_posix.cc
@@ -104,8 +104,8 @@
// static
PlatformThreadId PlatformThread::CurrentId() {
- // Pthreads doesn't have the concept of a thread ID, so we have to reach down
- // into the kernel.
+// Pthreads doesn't have the concept of a thread ID, so we have to reach down
+// into the kernel.
#if defined(OS_MACOSX)
return pthread_mach_thread_np(pthread_self());
#elif defined(OS_LINUX)
diff --git a/base/threading/platform_thread_win.cc b/base/threading/platform_thread_win.cc
index 9efc951..95accd5 100644
--- a/base/threading/platform_thread_win.cc
+++ b/base/threading/platform_thread_win.cc
@@ -21,10 +21,10 @@
const DWORD kVCThreadNameException = 0x406D1388;
typedef struct tagTHREADNAME_INFO {
- DWORD dwType; // Must be 0x1000.
- LPCSTR szName; // Pointer to name (in user addr space).
+ DWORD dwType; // Must be 0x1000.
+ LPCSTR szName; // Pointer to name (in user addr space).
DWORD dwThreadID; // Thread ID (-1=caller thread).
- DWORD dwFlags; // Reserved for future use, must be zero.
+ DWORD dwFlags; // Reserved for future use, must be zero.
} THREADNAME_INFO;
// The SetThreadDescription API was brought in version 1607 of Windows 10.
@@ -40,9 +40,9 @@
info.dwFlags = 0;
__try {
- RaiseException(kVCThreadNameException, 0, sizeof(info)/sizeof(DWORD),
+ RaiseException(kVCThreadNameException, 0, sizeof(info) / sizeof(DWORD),
reinterpret_cast<DWORD_PTR*>(&info));
- } __except(EXCEPTION_CONTINUE_EXECUTION) {
+ } __except (EXCEPTION_CONTINUE_EXECUTION) {
}
}
@@ -58,13 +58,9 @@
// Retrieve a copy of the thread handle to use as the key in the
// thread name mapping.
PlatformThreadHandle::Handle platform_handle;
- BOOL did_dup = DuplicateHandle(GetCurrentProcess(),
- GetCurrentThread(),
- GetCurrentProcess(),
- &platform_handle,
- 0,
- FALSE,
- DUPLICATE_SAME_ACCESS);
+ BOOL did_dup = DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
+ GetCurrentProcess(), &platform_handle, 0,
+ FALSE, DUPLICATE_SAME_ACCESS);
win::ScopedHandle scoped_platform_handle;
diff --git a/base/time/time.cc b/base/time/time.cc
index bd746b3..8708c49 100644
--- a/base/time/time.cc
+++ b/base/time/time.cc
@@ -98,7 +98,7 @@
return std::numeric_limits<int64_t>::max();
}
return (delta_ + Time::kMicrosecondsPerMillisecond - 1) /
- Time::kMicrosecondsPerMillisecond;
+ Time::kMicrosecondsPerMillisecond;
}
int64_t TimeDelta::InMicroseconds() const {
@@ -194,8 +194,8 @@
return std::numeric_limits<time_t>::max();
}
if (std::numeric_limits<int64_t>::max() - kTimeTToMicrosecondsOffset <= us_) {
- DLOG(WARNING) << "Overflow when converting base::Time with internal " <<
- "value " << us_ << " to time_t.";
+ DLOG(WARNING) << "Overflow when converting base::Time with internal "
+ << "value " << us_ << " to time_t.";
return std::numeric_limits<time_t>::max();
}
return (us_ - kTimeTToMicrosecondsOffset) / kMicrosecondsPerSecond;
@@ -222,9 +222,8 @@
#if defined(OS_POSIX)
// static
Time Time::FromTimeSpec(const timespec& ts) {
- return FromDoubleT(ts.tv_sec +
- static_cast<double>(ts.tv_nsec) /
- base::Time::kNanosecondsPerSecond);
+ return FromDoubleT(ts.tv_sec + static_cast<double>(ts.tv_nsec) /
+ base::Time::kNanosecondsPerSecond);
}
#endif
@@ -263,8 +262,7 @@
// Preserve max without offset to prevent overflow.
return std::numeric_limits<int64_t>::max();
}
- return ((us_ - kTimeTToMicrosecondsOffset) /
- kMicrosecondsPerMillisecond);
+ return ((us_ - kTimeTToMicrosecondsOffset) / kMicrosecondsPerMillisecond);
}
// static
@@ -301,14 +299,10 @@
Time::Exploded exploded;
time.UTCExplode(&exploded);
// Use StringPrintf because iostreams formatting is painful.
- return os << StringPrintf("%04d-%02d-%02d %02d:%02d:%02d.%03d UTC",
- exploded.year,
- exploded.month,
- exploded.day_of_month,
- exploded.hour,
- exploded.minute,
- exploded.second,
- exploded.millisecond);
+ return os << StringPrintf(
+ "%04d-%02d-%02d %02d:%02d:%02d.%03d UTC", exploded.year,
+ exploded.month, exploded.day_of_month, exploded.hour,
+ exploded.minute, exploded.second, exploded.millisecond);
}
// TimeTicks ------------------------------------------------------------------
@@ -369,12 +363,9 @@
}
bool Time::Exploded::HasValidValues() const {
- return is_in_range(month, 1, 12) &&
- is_in_range(day_of_week, 0, 6) &&
- is_in_range(day_of_month, 1, 31) &&
- is_in_range(hour, 0, 23) &&
- is_in_range(minute, 0, 59) &&
- is_in_range(second, 0, 60) &&
+ return is_in_range(month, 1, 12) && is_in_range(day_of_week, 0, 6) &&
+ is_in_range(day_of_month, 1, 31) && is_in_range(hour, 0, 23) &&
+ is_in_range(minute, 0, 59) && is_in_range(second, 0, 60) &&
is_in_range(millisecond, 0, 999);
}
diff --git a/base/time/time.h b/base/time/time.h
index 931cf27..1243ac4 100644
--- a/base/time/time.h
+++ b/base/time/time.h
@@ -69,8 +69,8 @@
#endif
#if defined(OS_POSIX)
-#include <unistd.h>
#include <sys/time.h>
+#include <unistd.h>
#endif
#if defined(OS_WIN)
@@ -205,12 +205,8 @@
return TimeDelta(time_internal::SaturatedSub(*this, other.delta_));
}
- TimeDelta& operator+=(TimeDelta other) {
- return *this = (*this + other);
- }
- TimeDelta& operator-=(TimeDelta other) {
- return *this = (*this - other);
- }
+ TimeDelta& operator+=(TimeDelta other) { return *this = (*this + other); }
+ TimeDelta& operator-=(TimeDelta other) { return *this = (*this - other); }
constexpr TimeDelta operator-() const { return TimeDelta(-delta_); }
// Computations with numeric types. operator*() isn't constexpr because of a
@@ -317,7 +313,7 @@
// classes. Each subclass provides for strong type-checking to ensure
// semantically meaningful comparison/math of time values from the same clock
// source or timeline.
-template<class TimeClass>
+template <class TimeClass>
class TimeBase {
public:
static const int64_t kHoursPerDay = 24;
@@ -341,9 +337,7 @@
// Warning: Be careful when writing code that performs math on time values,
// since it's possible to produce a valid "zero" result that should not be
// interpreted as a "null" value.
- bool is_null() const {
- return us_ == 0;
- }
+ bool is_null() const { return us_ == 0; }
// Returns true if this object represents the maximum/minimum time.
bool is_max() const { return us_ == std::numeric_limits<int64_t>::max(); }
@@ -402,24 +396,12 @@
}
// Comparison operators
- bool operator==(TimeClass other) const {
- return us_ == other.us_;
- }
- bool operator!=(TimeClass other) const {
- return us_ != other.us_;
- }
- bool operator<(TimeClass other) const {
- return us_ < other.us_;
- }
- bool operator<=(TimeClass other) const {
- return us_ <= other.us_;
- }
- bool operator>(TimeClass other) const {
- return us_ > other.us_;
- }
- bool operator>=(TimeClass other) const {
- return us_ >= other.us_;
- }
+ bool operator==(TimeClass other) const { return us_ == other.us_; }
+ bool operator!=(TimeClass other) const { return us_ != other.us_; }
+ bool operator<(TimeClass other) const { return us_ < other.us_; }
+ bool operator<=(TimeClass other) const { return us_ <= other.us_; }
+ bool operator>(TimeClass other) const { return us_ > other.us_; }
+ bool operator>=(TimeClass other) const { return us_ >= other.us_; }
protected:
constexpr explicit TimeBase(int64_t us) : us_(us) {}
@@ -430,7 +412,7 @@
} // namespace time_internal
-template<class TimeClass>
+template <class TimeClass>
inline TimeClass operator+(TimeDelta delta, TimeClass t) {
return t + delta;
}
@@ -620,9 +602,7 @@
// Fills the given exploded structure with either the local time or UTC from
// this time structure (containing UTC).
- void UTCExplode(Exploded* exploded) const {
- return Explode(false, exploded);
- }
+ void UTCExplode(Exploded* exploded) const { return Explode(false, exploded); }
void LocalExplode(Exploded* exploded) const {
return Explode(true, exploded);
}
@@ -854,8 +834,7 @@
// thread is running.
class ThreadTicks : public time_internal::TimeBase<ThreadTicks> {
public:
- ThreadTicks() : TimeBase(0) {
- }
+ ThreadTicks() : TimeBase(0) {}
// Returns true if ThreadTicks::Now() is supported on this system.
static bool IsSupported() WARN_UNUSED_RESULT {
diff --git a/base/time/time_exploded_posix.cc b/base/time/time_exploded_posix.cc
index ae1b4df..c9ec2df 100644
--- a/base/time/time_exploded_posix.cc
+++ b/base/time/time_exploded_posix.cc
@@ -117,7 +117,7 @@
timestruct.tm_yday = 0; // mktime/timegm ignore this
timestruct.tm_isdst = -1; // attempt to figure it out
#if !defined(OS_NACL) && !defined(OS_SOLARIS) && !defined(OS_AIX)
- timestruct.tm_gmtoff = 0; // not a POSIX field, so mktime/timegm ignore
+ timestruct.tm_gmtoff = 0; // not a POSIX field, so mktime/timegm ignore
timestruct.tm_zone = nullptr; // not a POSIX field, so mktime/timegm ignore
#endif
diff --git a/base/time/time_mac.cc b/base/time/time_mac.cc
index 567696d..7b6452e 100644
--- a/base/time/time_mac.cc
+++ b/base/time/time_mac.cc
@@ -109,10 +109,8 @@
}
kern_return_t kr = thread_info(
- thread.get(),
- THREAD_BASIC_INFO,
- reinterpret_cast<thread_info_t>(&thread_info_data),
- &thread_info_count);
+ thread.get(), THREAD_BASIC_INFO,
+ reinterpret_cast<thread_info_t>(&thread_info_data), &thread_info_count);
MACH_DCHECK(kr == KERN_SUCCESS, kr) << "thread_info";
base::CheckedNumeric<int64_t> absolute_micros(
@@ -263,8 +261,8 @@
// Calculate milliseconds ourselves, since we rounded the |seconds|, making
// sure to round towards -infinity.
exploded->millisecond =
- (microsecond >= 0) ? microsecond / kMicrosecondsPerMillisecond :
- (microsecond - kMicrosecondsPerMillisecond + 1) /
+ (microsecond >= 0) ? microsecond / kMicrosecondsPerMillisecond
+ : (microsecond - kMicrosecondsPerMillisecond + 1) /
kMicrosecondsPerMillisecond;
}
#endif // OS_IOS
diff --git a/base/time/time_win.cc b/base/time/time_win.cc
index ba220d6..438049d 100644
--- a/base/time/time_win.cc
+++ b/base/time/time_win.cc
@@ -2,7 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-
// Windows Timer Primer
//
// A good article: http://www.ddj.com/windows/184416651
@@ -34,6 +33,7 @@
#include "base/time/time.h"
#include <windows.h>
+
#include <mmsystem.h>
#include <stdint.h>
@@ -58,7 +58,7 @@
void MicrosecondsToFileTime(int64_t us, FILETIME* ft) {
DCHECK_GE(us, 0LL) << "Time is less than 0, negative values are not "
- "representable in FILETIME";
+ "representable in FILETIME";
// Multiply by 10 to convert microseconds to 100-nanoseconds. Bit_cast will
// handle alignment problems. This only works on little-endian machines.
@@ -467,7 +467,7 @@
return g_time_ticks_now_ignoring_override_function();
}
-} // namespace
+} // namespace base
namespace subtle {
TimeTicks TimeTicksNowIgnoringOverride() {
@@ -488,7 +488,8 @@
// Vista. So if we are using QPC then we are consistent which is the same as
// being high resolution.
//
- // [1] https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx
+ // [1]
+ // https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx
//
// "In general, the performance counter results are consistent across all
// processors in multi-core and multi-processor systems, even when measured on
@@ -504,8 +505,8 @@
// static
TimeTicks::Clock TimeTicks::GetClock() {
- return IsHighResolution() ?
- Clock::WIN_QPC : Clock::WIN_ROLLOVER_PROTECTED_TIME_GET_TIME;
+ return IsHighResolution() ? Clock::WIN_QPC
+ : Clock::WIN_ROLLOVER_PROTECTED_TIME_GET_TIME;
}
// ThreadTicks ----------------------------------------------------------------
diff --git a/base/value_iterators.h b/base/value_iterators.h
index 878ae7b..4c814c5 100644
--- a/base/value_iterators.h
+++ b/base/value_iterators.h
@@ -57,10 +57,8 @@
dict_iterator& operator--();
dict_iterator operator--(int);
- friend bool operator==(const dict_iterator& lhs,
- const dict_iterator& rhs);
- friend bool operator!=(const dict_iterator& lhs,
- const dict_iterator& rhs);
+ friend bool operator==(const dict_iterator& lhs, const dict_iterator& rhs);
+ friend bool operator!=(const dict_iterator& lhs, const dict_iterator& rhs);
private:
DictStorage::iterator dict_iter_;
@@ -104,9 +102,9 @@
const_dict_iterator operator--(int);
friend bool operator==(const const_dict_iterator& lhs,
- const const_dict_iterator& rhs);
+ const const_dict_iterator& rhs);
friend bool operator!=(const const_dict_iterator& lhs,
- const const_dict_iterator& rhs);
+ const const_dict_iterator& rhs);
private:
DictStorage::const_iterator dict_iter_;
diff --git a/base/values.cc b/base/values.cc
index 905a468..0b348b7 100644
--- a/base/values.cc
+++ b/base/values.cc
@@ -23,8 +23,8 @@
namespace {
-const char* const kTypeNames[] = {"null", "boolean", "integer",
- "string", "binary", "dictionary", "list"};
+const char* const kTypeNames[] = {"null", "boolean", "integer", "string",
+ "binary", "dictionary", "list"};
static_assert(arraysize(kTypeNames) ==
static_cast<size_t>(Value::Type::LIST) + 1,
"kTypeNames Has Wrong Size");
@@ -525,12 +525,11 @@
case Value::Type::DICTIONARY:
if (lhs.dict_.size() != rhs.dict_.size())
return false;
- return std::equal(std::begin(lhs.dict_), std::end(lhs.dict_),
- std::begin(rhs.dict_),
- [](const auto& u, const auto& v) {
- return std::tie(u.first, *u.second) ==
- std::tie(v.first, *v.second);
- });
+ return std::equal(
+ std::begin(lhs.dict_), std::end(lhs.dict_), std::begin(rhs.dict_),
+ [](const auto& u, const auto& v) {
+ return std::tie(u.first, *u.second) == std::tie(v.first, *v.second);
+ });
case Value::Type::LIST:
return lhs.list_ == rhs.list_;
}
@@ -738,8 +737,7 @@
return result.first->second.get();
}
-bool DictionaryValue::Get(StringPiece path,
- const Value** out_value) const {
+bool DictionaryValue::Get(StringPiece path, const Value** out_value) const {
DCHECK(IsStringUTF8(path));
StringPiece current_path(path);
const DictionaryValue* current_dictionary = this;
@@ -759,10 +757,9 @@
return current_dictionary->GetWithoutPathExpansion(current_path, out_value);
}
-bool DictionaryValue::Get(StringPiece path, Value** out_value) {
+bool DictionaryValue::Get(StringPiece path, Value** out_value) {
return static_cast<const DictionaryValue&>(*this).Get(
- path,
- const_cast<const Value**>(out_value));
+ path, const_cast<const Value**>(out_value));
}
bool DictionaryValue::GetBoolean(StringPiece path, bool* bool_value) const {
@@ -847,8 +844,7 @@
bool DictionaryValue::GetDictionary(StringPiece path,
DictionaryValue** out_value) {
return static_cast<const DictionaryValue&>(*this).GetDictionary(
- path,
- const_cast<const DictionaryValue**>(out_value));
+ path, const_cast<const DictionaryValue**>(out_value));
}
bool DictionaryValue::GetList(StringPiece path,
@@ -866,8 +862,7 @@
bool DictionaryValue::GetList(StringPiece path, ListValue** out_value) {
return static_cast<const DictionaryValue&>(*this).GetList(
- path,
- const_cast<const ListValue**>(out_value));
+ path, const_cast<const ListValue**>(out_value));
}
bool DictionaryValue::GetWithoutPathExpansion(StringPiece key,
@@ -885,8 +880,7 @@
bool DictionaryValue::GetWithoutPathExpansion(StringPiece key,
Value** out_value) {
return static_cast<const DictionaryValue&>(*this).GetWithoutPathExpansion(
- key,
- const_cast<const Value**>(out_value));
+ key, const_cast<const Value**>(out_value));
}
bool DictionaryValue::GetBooleanWithoutPathExpansion(StringPiece key,
@@ -946,8 +940,7 @@
const DictionaryValue& const_this =
static_cast<const DictionaryValue&>(*this);
return const_this.GetDictionaryWithoutPathExpansion(
- key,
- const_cast<const DictionaryValue**>(out_value));
+ key, const_cast<const DictionaryValue**>(out_value));
}
bool DictionaryValue::GetListWithoutPathExpansion(
@@ -966,10 +959,8 @@
bool DictionaryValue::GetListWithoutPathExpansion(StringPiece key,
ListValue** out_value) {
- return
- static_cast<const DictionaryValue&>(*this).GetListWithoutPathExpansion(
- key,
- const_cast<const ListValue**>(out_value));
+ return static_cast<const DictionaryValue&>(*this).GetListWithoutPathExpansion(
+ key, const_cast<const ListValue**>(out_value));
}
bool DictionaryValue::Remove(StringPiece path,
@@ -1015,8 +1006,7 @@
DictionaryValue* subdict = nullptr;
if (!GetDictionary(subdict_path, &subdict))
return false;
- result = subdict->RemovePath(path.substr(delimiter_position + 1),
- out_value);
+ result = subdict->RemovePath(path.substr(delimiter_position + 1), out_value);
if (result && subdict->empty())
RemoveWithoutPathExpansion(subdict_path, nullptr);
@@ -1118,8 +1108,7 @@
bool ListValue::Get(size_t index, Value** out_value) {
return static_cast<const ListValue&>(*this).Get(
- index,
- const_cast<const Value**>(out_value));
+ index, const_cast<const Value**>(out_value));
}
bool ListValue::GetBoolean(size_t index, bool* bool_value) const {
@@ -1169,8 +1158,7 @@
bool ListValue::GetDictionary(size_t index, DictionaryValue** out_value) {
return static_cast<const ListValue&>(*this).GetDictionary(
- index,
- const_cast<const DictionaryValue**>(out_value));
+ index, const_cast<const DictionaryValue**>(out_value));
}
bool ListValue::GetList(size_t index, const ListValue** out_value) const {
@@ -1187,8 +1175,7 @@
bool ListValue::GetList(size_t index, ListValue** out_value) {
return static_cast<const ListValue&>(*this).GetList(
- index,
- const_cast<const ListValue**>(out_value));
+ index, const_cast<const ListValue**>(out_value));
}
bool ListValue::Remove(size_t index, std::unique_ptr<Value>* out_value) {
diff --git a/base/values.h b/base/values.h
index 99e00c5..c3ec875 100644
--- a/base/values.h
+++ b/base/values.h
@@ -460,8 +460,7 @@
// DEPRECATED, use Value::FindPath(path) and Value::GetBlob() instead.
bool GetBinary(StringPiece path, Value** out_value);
// DEPRECATED, use Value::FindPath(path) and Value's Dictionary API instead.
- bool GetDictionary(StringPiece path,
- const DictionaryValue** out_value) const;
+ bool GetDictionary(StringPiece path, const DictionaryValue** out_value) const;
// DEPRECATED, use Value::FindPath(path) and Value's Dictionary API instead.
bool GetDictionary(StringPiece path, DictionaryValue** out_value);
// DEPRECATED, use Value::FindPath(path) and Value::GetList() instead.
@@ -742,18 +741,16 @@
std::ostream& operator<<(std::ostream& out, const Value& value);
inline std::ostream& operator<<(std::ostream& out,
- const DictionaryValue& value) {
+ const DictionaryValue& value) {
return out << static_cast<const Value&>(value);
}
-inline std::ostream& operator<<(std::ostream& out,
- const ListValue& value) {
+inline std::ostream& operator<<(std::ostream& out, const ListValue& value) {
return out << static_cast<const Value&>(value);
}
// Stream operator so that enum class Types can be used in log statements.
-std::ostream& operator<<(std::ostream& out,
- const Value::Type& type);
+std::ostream& operator<<(std::ostream& out, const Value::Type& type);
} // namespace base
diff --git a/base/win/com_init_check_hook.cc b/base/win/com_init_check_hook.cc
index 3da7622..7055bb0 100644
--- a/base/win/com_init_check_hook.cc
+++ b/base/win/com_init_check_hook.cc
@@ -4,10 +4,10 @@
#include "base/win/com_init_check_hook.h"
-#include <windows.h>
#include <objbase.h>
#include <stdint.h>
#include <string.h>
+#include <windows.h>
#include "base/strings/stringprintf.h"
#include "base/synchronization/lock.h"
@@ -134,7 +134,8 @@
// See banner comment above why this subtracts 5 bytes.
co_create_instance_padded_address_ =
reinterpret_cast<uint32_t>(
- GetProcAddress(ole32_library_, "CoCreateInstance")) - 5;
+ GetProcAddress(ole32_library_, "CoCreateInstance")) -
+ 5;
// See banner comment above why this adds 7 bytes.
original_co_create_instance_body_function_ =
diff --git a/base/win/core_winrt_util.h b/base/win/core_winrt_util.h
index 4698f78..d760c79 100644
--- a/base/win/core_winrt_util.h
+++ b/base/win/core_winrt_util.h
@@ -30,11 +30,10 @@
void RoUninitialize();
HRESULT RoGetActivationFactory(HSTRING class_id,
- const IID& iid,
- void** out_factory);
+ const IID& iid,
+ void** out_factory);
-HRESULT RoActivateInstance(HSTRING class_id,
- IInspectable** instance);
+HRESULT RoActivateInstance(HSTRING class_id, IInspectable** instance);
// Retrieves an activation factory for the type specified.
template <typename InterfaceType, char16 const* runtime_class_id>
diff --git a/base/win/enum_variant.cc b/base/win/enum_variant.cc
index 2975560..fd81775 100644
--- a/base/win/enum_variant.cc
+++ b/base/win/enum_variant.cc
@@ -12,13 +12,9 @@
namespace win {
EnumVariant::EnumVariant(unsigned long count)
- : items_(new VARIANT[count]),
- count_(count),
- current_index_(0) {
-}
+ : items_(new VARIANT[count]), count_(count), current_index_(0) {}
-EnumVariant::~EnumVariant() {
-}
+EnumVariant::~EnumVariant() {}
VARIANT* EnumVariant::ItemAt(unsigned long index) {
DCHECK(index < count_);
diff --git a/base/win/enum_variant.h b/base/win/enum_variant.h
index b61fc8f..d12f350 100644
--- a/base/win/enum_variant.h
+++ b/base/win/enum_variant.h
@@ -15,9 +15,7 @@
namespace win {
// A simple implementation of IEnumVARIANT.
-class EnumVariant
- : public IEnumVARIANT,
- public IUnknownImpl {
+class EnumVariant : public IEnumVARIANT, public IUnknownImpl {
public:
// The constructor allocates an array of size |count|. Then use
// ItemAt to set the value of each item in the array to initialize it.
diff --git a/base/win/event_trace_consumer.h b/base/win/event_trace_consumer.h
index 9f97e0d..93e8a24 100644
--- a/base/win/event_trace_consumer.h
+++ b/base/win/event_trace_consumer.h
@@ -6,10 +6,10 @@
#ifndef BASE_WIN_EVENT_TRACE_CONSUMER_H_
#define BASE_WIN_EVENT_TRACE_CONSUMER_H_
-#include <windows.h>
-#include <wmistr.h>
#include <evntrace.h>
#include <stddef.h>
+#include <windows.h>
+#include <wmistr.h>
#include <vector>
#include "base/macros.h"
@@ -34,12 +34,9 @@
class EtwTraceConsumerBase {
public:
// Constructs a closed consumer.
- EtwTraceConsumerBase() {
- }
+ EtwTraceConsumerBase() {}
- ~EtwTraceConsumerBase() {
- Close();
- }
+ ~EtwTraceConsumerBase() { Close(); }
// Opens the named realtime session, which must be existent.
// Note: You can use OpenRealtimeSession or OpenFileSession
@@ -62,8 +59,7 @@
protected:
// Override in subclasses to handle events.
- static void ProcessEvent(EVENT_TRACE* event) {
- }
+ static void ProcessEvent(EVENT_TRACE* event) {}
// Override in subclasses to handle buffers.
static bool ProcessBuffer(EVENT_TRACE_LOGFILE* buffer) {
return true; // keep going
@@ -85,8 +81,8 @@
DISALLOW_COPY_AND_ASSIGN(EtwTraceConsumerBase);
};
-template <class ImplClass> inline
-HRESULT EtwTraceConsumerBase<ImplClass>::OpenRealtimeSession(
+template <class ImplClass>
+inline HRESULT EtwTraceConsumerBase<ImplClass>::OpenRealtimeSession(
const wchar_t* session_name) {
EVENT_TRACE_LOGFILE logfile = {};
logfile.LoggerName = const_cast<wchar_t*>(session_name);
@@ -102,8 +98,8 @@
return S_OK;
}
-template <class ImplClass> inline
-HRESULT EtwTraceConsumerBase<ImplClass>::OpenFileSession(
+template <class ImplClass>
+inline HRESULT EtwTraceConsumerBase<ImplClass>::OpenFileSession(
const wchar_t* file_name) {
EVENT_TRACE_LOGFILE logfile = {};
logfile.LogFileName = const_cast<wchar_t*>(file_name);
@@ -118,17 +114,16 @@
return S_OK;
}
-template <class ImplClass> inline
-HRESULT EtwTraceConsumerBase<ImplClass>::Consume() {
- ULONG err = ::ProcessTrace(&trace_handles_[0],
- static_cast<ULONG>(trace_handles_.size()),
- NULL,
- NULL);
+template <class ImplClass>
+inline HRESULT EtwTraceConsumerBase<ImplClass>::Consume() {
+ ULONG err =
+ ::ProcessTrace(&trace_handles_[0],
+ static_cast<ULONG>(trace_handles_.size()), NULL, NULL);
return HRESULT_FROM_WIN32(err);
}
-template <class ImplClass> inline
-HRESULT EtwTraceConsumerBase<ImplClass>::Close() {
+template <class ImplClass>
+inline HRESULT EtwTraceConsumerBase<ImplClass>::Close() {
HRESULT hr = S_OK;
for (size_t i = 0; i < trace_handles_.size(); ++i) {
if (NULL != trace_handles_[i]) {
diff --git a/base/win/event_trace_controller.cc b/base/win/event_trace_controller.cc
deleted file mode 100644
index ff392a3..0000000
--- a/base/win/event_trace_controller.cc
+++ /dev/null
@@ -1,174 +0,0 @@
-// Copyright (c) 2009 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.
-//
-// Implementation of a Windows event trace controller class.
-#include "base/win/event_trace_controller.h"
-#include "base/logging.h"
-
-namespace base {
-namespace win {
-
-EtwTraceProperties::EtwTraceProperties() {
- memset(buffer_, 0, sizeof(buffer_));
- EVENT_TRACE_PROPERTIES* prop = get();
-
- prop->Wnode.BufferSize = sizeof(buffer_);
- prop->Wnode.Flags = WNODE_FLAG_TRACED_GUID;
- prop->LoggerNameOffset = sizeof(EVENT_TRACE_PROPERTIES);
- prop->LogFileNameOffset = sizeof(EVENT_TRACE_PROPERTIES) +
- sizeof(wchar_t) * kMaxStringLen;
-}
-
-HRESULT EtwTraceProperties::SetLoggerName(const wchar_t* logger_name) {
- size_t len = wcslen(logger_name) + 1;
- if (kMaxStringLen < len)
- return E_INVALIDARG;
-
- memcpy(buffer_ + get()->LoggerNameOffset,
- logger_name,
- sizeof(wchar_t) * len);
- return S_OK;
-}
-
-HRESULT EtwTraceProperties::SetLoggerFileName(const wchar_t* logger_file_name) {
- size_t len = wcslen(logger_file_name) + 1;
- if (kMaxStringLen < len)
- return E_INVALIDARG;
-
- memcpy(buffer_ + get()->LogFileNameOffset,
- logger_file_name,
- sizeof(wchar_t) * len);
- return S_OK;
-}
-
-EtwTraceController::EtwTraceController() : session_(NULL) {
-}
-
-EtwTraceController::~EtwTraceController() {
- if (session_)
- Stop(NULL);
-}
-
-HRESULT EtwTraceController::Start(const wchar_t* session_name,
- EtwTraceProperties* prop) {
- DCHECK(NULL == session_ && session_name_.empty());
- EtwTraceProperties ignore;
- if (prop == NULL)
- prop = &ignore;
-
- HRESULT hr = Start(session_name, prop, &session_);
- if (SUCCEEDED(hr))
- session_name_ = session_name;
-
- return hr;
-}
-
-HRESULT EtwTraceController::StartFileSession(const wchar_t* session_name,
- const wchar_t* logfile_path, bool realtime) {
- DCHECK(NULL == session_ && session_name_.empty());
-
- EtwTraceProperties prop;
- prop.SetLoggerFileName(logfile_path);
- EVENT_TRACE_PROPERTIES& p = *prop.get();
- p.Wnode.ClientContext = 1; // QPC timer accuracy.
- p.LogFileMode = EVENT_TRACE_FILE_MODE_SEQUENTIAL; // Sequential log.
- if (realtime)
- p.LogFileMode |= EVENT_TRACE_REAL_TIME_MODE;
-
- p.MaximumFileSize = 100; // 100M file size.
- p.FlushTimer = 30; // 30 seconds flush lag.
- return Start(session_name, &prop);
-}
-
-HRESULT EtwTraceController::StartRealtimeSession(const wchar_t* session_name,
- size_t buffer_size) {
- DCHECK(NULL == session_ && session_name_.empty());
- EtwTraceProperties prop;
- EVENT_TRACE_PROPERTIES& p = *prop.get();
- p.LogFileMode = EVENT_TRACE_REAL_TIME_MODE | EVENT_TRACE_USE_PAGED_MEMORY;
- p.FlushTimer = 1; // flush every second.
- p.BufferSize = 16; // 16 K buffers.
- p.LogFileNameOffset = 0;
- return Start(session_name, &prop);
-}
-
-HRESULT EtwTraceController::EnableProvider(REFGUID provider, UCHAR level,
- ULONG flags) {
- ULONG error = ::EnableTrace(TRUE, flags, level, &provider, session_);
- return HRESULT_FROM_WIN32(error);
-}
-
-HRESULT EtwTraceController::DisableProvider(REFGUID provider) {
- ULONG error = ::EnableTrace(FALSE, 0, 0, &provider, session_);
- return HRESULT_FROM_WIN32(error);
-}
-
-HRESULT EtwTraceController::Stop(EtwTraceProperties* properties) {
- EtwTraceProperties ignore;
- if (properties == NULL)
- properties = &ignore;
-
- ULONG error = ::ControlTrace(session_, NULL, properties->get(),
- EVENT_TRACE_CONTROL_STOP);
- if (ERROR_SUCCESS != error)
- return HRESULT_FROM_WIN32(error);
-
- session_ = NULL;
- session_name_.clear();
- return S_OK;
-}
-
-HRESULT EtwTraceController::Flush(EtwTraceProperties* properties) {
- EtwTraceProperties ignore;
- if (properties == NULL)
- properties = &ignore;
-
- ULONG error = ::ControlTrace(session_, NULL, properties->get(),
- EVENT_TRACE_CONTROL_FLUSH);
- if (ERROR_SUCCESS != error)
- return HRESULT_FROM_WIN32(error);
-
- return S_OK;
-}
-
-HRESULT EtwTraceController::Start(const wchar_t* session_name,
- EtwTraceProperties* properties, TRACEHANDLE* session_handle) {
- DCHECK(properties != NULL);
- ULONG err = ::StartTrace(session_handle, session_name, properties->get());
- return HRESULT_FROM_WIN32(err);
-}
-
-HRESULT EtwTraceController::Query(const wchar_t* session_name,
- EtwTraceProperties* properties) {
- ULONG err = ::ControlTrace(NULL, session_name, properties->get(),
- EVENT_TRACE_CONTROL_QUERY);
- return HRESULT_FROM_WIN32(err);
-};
-
-HRESULT EtwTraceController::Update(const wchar_t* session_name,
- EtwTraceProperties* properties) {
- DCHECK(properties != NULL);
- ULONG err = ::ControlTrace(NULL, session_name, properties->get(),
- EVENT_TRACE_CONTROL_UPDATE);
- return HRESULT_FROM_WIN32(err);
-}
-
-HRESULT EtwTraceController::Stop(const wchar_t* session_name,
- EtwTraceProperties* properties) {
- DCHECK(properties != NULL);
- ULONG err = ::ControlTrace(NULL, session_name, properties->get(),
- EVENT_TRACE_CONTROL_STOP);
- return HRESULT_FROM_WIN32(err);
-}
-
-HRESULT EtwTraceController::Flush(const wchar_t* session_name,
- EtwTraceProperties* properties) {
- DCHECK(properties != NULL);
- ULONG err = ::ControlTrace(NULL, session_name, properties->get(),
- EVENT_TRACE_CONTROL_FLUSH);
- return HRESULT_FROM_WIN32(err);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/event_trace_controller.h b/base/win/event_trace_controller.h
deleted file mode 100644
index 17b82bc..0000000
--- a/base/win/event_trace_controller.h
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright (c) 2011 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.
-//
-// Declaration of a Windows event trace controller class.
-// The controller takes care of creating and manipulating event trace
-// sessions.
-//
-// Event tracing for Windows is a system-provided service that provides
-// logging control and high-performance transport for generic, binary trace
-// events. Event trace providers register with the system by their name,
-// which is a GUID, and can from that point forward receive callbacks that
-// start or end tracing and that change their trace level and enable mask.
-//
-// A trace controller can create an event tracing session, which either
-// sends events to a binary file, or to a realtime consumer, or both.
-//
-// A trace consumer consumes events from zero or one realtime session,
-// as well as potentially from multiple binary trace files.
-#ifndef BASE_WIN_EVENT_TRACE_CONTROLLER_H_
-#define BASE_WIN_EVENT_TRACE_CONTROLLER_H_
-
-#include <windows.h>
-#include <wmistr.h>
-#include <evntrace.h>
-#include <stddef.h>
-#include <string>
-
-#include "base/macros.h"
-
-namespace base {
-namespace win {
-
-// Utility class to make it easier to work with EVENT_TRACE_PROPERTIES.
-// The EVENT_TRACE_PROPERTIES structure contains information about an
-// event tracing session.
-class EtwTraceProperties {
- public:
- EtwTraceProperties();
-
- EVENT_TRACE_PROPERTIES* get() {
- return &properties_;
- }
-
- const EVENT_TRACE_PROPERTIES* get() const {
- return reinterpret_cast<const EVENT_TRACE_PROPERTIES*>(&properties_);
- }
-
- const wchar_t* GetLoggerName() const {
- return reinterpret_cast<const wchar_t *>(buffer_ + get()->LoggerNameOffset);
- }
-
- // Copies logger_name to the properties structure.
- HRESULT SetLoggerName(const wchar_t* logger_name);
- const wchar_t* GetLoggerFileName() const {
- return reinterpret_cast<const wchar_t*>(buffer_ + get()->LogFileNameOffset);
- }
-
- // Copies logger_file_name to the properties structure.
- HRESULT SetLoggerFileName(const wchar_t* logger_file_name);
-
- // Max string len for name and session name is 1024 per documentation.
- static const size_t kMaxStringLen = 1024;
- // Properties buffer allocates space for header and for
- // max length for name and session name.
- static const size_t kBufSize = sizeof(EVENT_TRACE_PROPERTIES)
- + 2 * sizeof(wchar_t) * (kMaxStringLen);
-
- private:
- // The EVENT_TRACE_PROPERTIES structure needs to be overlaid on a
- // larger buffer to allow storing the logger name and logger file
- // name contiguously with the structure.
- union {
- public:
- // Our properties header.
- EVENT_TRACE_PROPERTIES properties_;
- // The actual size of the buffer is forced by this member.
- char buffer_[kBufSize];
- };
-
- DISALLOW_COPY_AND_ASSIGN(EtwTraceProperties);
-};
-
-// This class implements an ETW controller, which knows how to start and
-// stop event tracing sessions, as well as controlling ETW provider
-// log levels and enable bit masks under the session.
-class EtwTraceController {
- public:
- EtwTraceController();
- ~EtwTraceController();
-
- // Start a session with given name and properties.
- HRESULT Start(const wchar_t* session_name, EtwTraceProperties* prop);
-
- // Starts a session tracing to a file with some default properties.
- HRESULT StartFileSession(const wchar_t* session_name,
- const wchar_t* logfile_path,
- bool realtime = false);
-
- // Starts a realtime session with some default properties.
- HRESULT StartRealtimeSession(const wchar_t* session_name,
- size_t buffer_size);
-
- // Enables "provider" at "level" for this session.
- // This will cause all providers registered with the GUID
- // "provider" to start tracing at the new level, systemwide.
- HRESULT EnableProvider(const GUID& provider, UCHAR level,
- ULONG flags = 0xFFFFFFFF);
- // Disables "provider".
- HRESULT DisableProvider(const GUID& provider);
-
- // Stops our session and retrieve the new properties of the session,
- // properties may be NULL.
- HRESULT Stop(EtwTraceProperties* properties);
-
- // Flushes our session and retrieve the current properties,
- // properties may be NULL.
- HRESULT Flush(EtwTraceProperties* properties);
-
- // Static utility functions for controlling
- // sessions we don't necessarily own.
- static HRESULT Start(const wchar_t* session_name,
- EtwTraceProperties* properties,
- TRACEHANDLE* session_handle);
-
- static HRESULT Query(const wchar_t* session_name,
- EtwTraceProperties* properties);
-
- static HRESULT Update(const wchar_t* session_name,
- EtwTraceProperties* properties);
-
- static HRESULT Stop(const wchar_t* session_name,
- EtwTraceProperties* properties);
- static HRESULT Flush(const wchar_t* session_name,
- EtwTraceProperties* properties);
-
- // Accessors.
- TRACEHANDLE session() const { return session_; }
- const wchar_t* session_name() const { return session_name_.c_str(); }
-
- private:
- std::wstring session_name_;
- TRACEHANDLE session_;
-
- DISALLOW_COPY_AND_ASSIGN(EtwTraceController);
-};
-
-} // namespace win
-} // namespace base
-
-#endif // BASE_WIN_EVENT_TRACE_CONTROLLER_H_
diff --git a/base/win/event_trace_provider.cc b/base/win/event_trace_provider.cc
deleted file mode 100644
index 8fcf67d..0000000
--- a/base/win/event_trace_provider.cc
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-#include "base/win/event_trace_provider.h"
-#include <windows.h>
-#include <cguid.h>
-
-namespace base {
-namespace win {
-
-TRACE_GUID_REGISTRATION EtwTraceProvider::obligatory_guid_registration_ = {
- &GUID_NULL,
- NULL
-};
-
-EtwTraceProvider::EtwTraceProvider(const GUID& provider_name)
- : provider_name_(provider_name), registration_handle_(NULL),
- session_handle_(NULL), enable_flags_(0), enable_level_(0) {
-}
-
-EtwTraceProvider::EtwTraceProvider()
- : provider_name_(GUID_NULL), registration_handle_(NULL),
- session_handle_(NULL), enable_flags_(0), enable_level_(0) {
-}
-
-EtwTraceProvider::~EtwTraceProvider() {
- Unregister();
-}
-
-ULONG EtwTraceProvider::EnableEvents(void* buffer) {
- session_handle_ = ::GetTraceLoggerHandle(buffer);
- if (NULL == session_handle_) {
- return ::GetLastError();
- }
-
- enable_flags_ = ::GetTraceEnableFlags(session_handle_);
- enable_level_ = ::GetTraceEnableLevel(session_handle_);
-
- // Give subclasses a chance to digest the state change.
- OnEventsEnabled();
-
- return ERROR_SUCCESS;
-}
-
-ULONG EtwTraceProvider::DisableEvents() {
- // Give subclasses a chance to digest the state change.
- OnEventsDisabled();
-
- enable_level_ = 0;
- enable_flags_ = 0;
- session_handle_ = NULL;
-
- PostEventsDisabled();
-
- return ERROR_SUCCESS;
-}
-
-ULONG EtwTraceProvider::Callback(WMIDPREQUESTCODE request, void* buffer) {
- switch (request) {
- case WMI_ENABLE_EVENTS:
- return EnableEvents(buffer);
- case WMI_DISABLE_EVENTS:
- return DisableEvents();
- default:
- return ERROR_INVALID_PARAMETER;
- }
- // Not reached.
-}
-
-ULONG WINAPI EtwTraceProvider::ControlCallback(WMIDPREQUESTCODE request,
- void* context, ULONG *reserved, void* buffer) {
- EtwTraceProvider *provider = reinterpret_cast<EtwTraceProvider*>(context);
-
- return provider->Callback(request, buffer);
-}
-
-ULONG EtwTraceProvider::Register() {
- if (provider_name_ == GUID_NULL)
- return ERROR_INVALID_NAME;
-
- return ::RegisterTraceGuids(ControlCallback, this, &provider_name_,
- 1, &obligatory_guid_registration_, NULL, NULL, ®istration_handle_);
-}
-
-ULONG EtwTraceProvider::Unregister() {
- // If a session is active, notify subclasses that it's going away.
- if (session_handle_ != NULL)
- DisableEvents();
-
- ULONG ret = ::UnregisterTraceGuids(registration_handle_);
-
- registration_handle_ = NULL;
-
- return ret;
-}
-
-ULONG EtwTraceProvider::Log(const EtwEventClass& event_class,
- EtwEventType type, EtwEventLevel level, const char *message) {
- if (NULL == session_handle_ || enable_level_ < level)
- return ERROR_SUCCESS; // No one listening.
-
- EtwMofEvent<1> event(event_class, type, level);
-
- event.fields[0].DataPtr = reinterpret_cast<ULONG64>(message);
- event.fields[0].Length = message ?
- static_cast<ULONG>(sizeof(message[0]) * (1 + strlen(message))) : 0;
-
- return ::TraceEvent(session_handle_, &event.header);
-}
-
-ULONG EtwTraceProvider::Log(const EtwEventClass& event_class,
- EtwEventType type, EtwEventLevel level, const wchar_t *message) {
- if (NULL == session_handle_ || enable_level_ < level)
- return ERROR_SUCCESS; // No one listening.
-
- EtwMofEvent<1> event(event_class, type, level);
-
- event.fields[0].DataPtr = reinterpret_cast<ULONG64>(message);
- event.fields[0].Length = message ?
- static_cast<ULONG>(sizeof(message[0]) * (1 + wcslen(message))) : 0;
-
- return ::TraceEvent(session_handle_, &event.header);
-}
-
-ULONG EtwTraceProvider::Log(EVENT_TRACE_HEADER* event) {
- if (enable_level_ < event->Class.Level)
- return ERROR_SUCCESS;
-
- return ::TraceEvent(session_handle_, event);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/event_trace_provider.h b/base/win/event_trace_provider.h
deleted file mode 100644
index 321f539..0000000
--- a/base/win/event_trace_provider.h
+++ /dev/null
@@ -1,183 +0,0 @@
-// Copyright (c) 2011 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.
-//
-// Declaration of a Windows event trace provider class, to allow using
-// Windows Event Tracing for logging transport and control.
-#ifndef BASE_WIN_EVENT_TRACE_PROVIDER_H_
-#define BASE_WIN_EVENT_TRACE_PROVIDER_H_
-
-#include <windows.h>
-#include <wmistr.h>
-#include <evntrace.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <limits>
-
-#include "base/macros.h"
-
-namespace base {
-namespace win {
-
-typedef GUID EtwEventClass;
-typedef UCHAR EtwEventType;
-typedef UCHAR EtwEventLevel;
-typedef USHORT EtwEventVersion;
-typedef ULONG EtwEventFlags;
-
-// Base class is a POD for correctness.
-template <size_t N> struct EtwMofEventBase {
- EVENT_TRACE_HEADER header;
- MOF_FIELD fields[N];
-};
-
-// Utility class to auto-initialize event trace header structures.
-template <size_t N> class EtwMofEvent: public EtwMofEventBase<N> {
- public:
- typedef EtwMofEventBase<N> Super;
-
- // Clang and the C++ standard don't allow unqualified lookup into dependent
- // bases, hence these using decls to explicitly pull the names out.
- using EtwMofEventBase<N>::header;
- using EtwMofEventBase<N>::fields;
-
- EtwMofEvent() {
- memset(static_cast<Super*>(this), 0, sizeof(Super));
- }
-
- EtwMofEvent(const EtwEventClass& event_class, EtwEventType type,
- EtwEventLevel level) {
- memset(static_cast<Super*>(this), 0, sizeof(Super));
- header.Size = sizeof(Super);
- header.Guid = event_class;
- header.Class.Type = type;
- header.Class.Level = level;
- header.Flags = WNODE_FLAG_TRACED_GUID | WNODE_FLAG_USE_MOF_PTR;
- }
-
- EtwMofEvent(const EtwEventClass& event_class, EtwEventType type,
- EtwEventVersion version, EtwEventLevel level) {
- memset(static_cast<Super*>(this), 0, sizeof(Super));
- header.Size = sizeof(Super);
- header.Guid = event_class;
- header.Class.Type = type;
- header.Class.Version = version;
- header.Class.Level = level;
- header.Flags = WNODE_FLAG_TRACED_GUID | WNODE_FLAG_USE_MOF_PTR;
- }
-
- void SetField(size_t field, size_t size, const void* data) {
- // DCHECK(field < N);
- if ((field < N) && (size <= std::numeric_limits<uint32_t>::max())) {
- fields[field].DataPtr = reinterpret_cast<ULONG64>(data);
- fields[field].Length = static_cast<ULONG>(size);
- }
- }
-
- EVENT_TRACE_HEADER* get() { return& header; }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(EtwMofEvent);
-};
-
-// Trace provider with Event Tracing for Windows. The trace provider
-// registers with ETW by its name which is a GUID. ETW calls back to
-// the object whenever the trace level or enable flags for this provider
-// name changes.
-// Users of this class can test whether logging is currently enabled at
-// a particular trace level, and whether particular enable flags are set,
-// before other resources are consumed to generate and issue the log
-// messages themselves.
-class EtwTraceProvider {
- public:
- // Creates an event trace provider identified by provider_name, which
- // will be the name registered with Event Tracing for Windows (ETW).
- explicit EtwTraceProvider(const GUID& provider_name);
-
- // Creates an unnamed event trace provider, the provider must be given
- // a name before registration.
- EtwTraceProvider();
- virtual ~EtwTraceProvider();
-
- // Registers the trace provider with Event Tracing for Windows.
- // Note: from this point forward ETW may call the provider's control
- // callback. If the provider's name is enabled in some trace session
- // already, the callback may occur recursively from this call, so
- // call this only when you're ready to handle callbacks.
- ULONG Register();
- // Unregisters the trace provider with ETW.
- ULONG Unregister();
-
- // Accessors.
- void set_provider_name(const GUID& provider_name) {
- provider_name_ = provider_name;
- }
- const GUID& provider_name() const { return provider_name_; }
- TRACEHANDLE registration_handle() const { return registration_handle_; }
- TRACEHANDLE session_handle() const { return session_handle_; }
- EtwEventFlags enable_flags() const { return enable_flags_; }
- EtwEventLevel enable_level() const { return enable_level_; }
-
- // Returns true iff logging should be performed for "level" and "flags".
- // Note: flags is treated as a bitmask, and should normally have a single
- // bit set, to test whether to log for a particular sub "facility".
- bool ShouldLog(EtwEventLevel level, EtwEventFlags flags) {
- return NULL != session_handle_ && level >= enable_level_ &&
- (0 != (flags & enable_flags_));
- }
-
- // Simple wrappers to log Unicode and ANSI strings.
- // Do nothing if !ShouldLog(level, 0xFFFFFFFF).
- ULONG Log(const EtwEventClass& event_class, EtwEventType type,
- EtwEventLevel level, const char *message);
- ULONG Log(const EtwEventClass& event_class, EtwEventType type,
- EtwEventLevel level, const wchar_t *message);
-
- // Log the provided event.
- ULONG Log(EVENT_TRACE_HEADER* event);
-
- protected:
- // Called after events have been enabled, override in subclasses
- // to set up state or log at the start of a session.
- // Note: This function may be called ETW's thread and may be racy,
- // bring your own locking if needed.
- virtual void OnEventsEnabled() {}
-
- // Called just before events are disabled, override in subclasses
- // to tear down state or log at the end of a session.
- // Note: This function may be called ETW's thread and may be racy,
- // bring your own locking if needed.
- virtual void OnEventsDisabled() {}
-
- // Called just after events have been disabled, override in subclasses
- // to tear down state at the end of a session. At this point it's
- // to late to log anything to the session.
- // Note: This function may be called ETW's thread and may be racy,
- // bring your own locking if needed.
- virtual void PostEventsDisabled() {}
-
- private:
- ULONG EnableEvents(PVOID buffer);
- ULONG DisableEvents();
- ULONG Callback(WMIDPREQUESTCODE request, PVOID buffer);
- static ULONG WINAPI ControlCallback(WMIDPREQUESTCODE request, PVOID context,
- ULONG *reserved, PVOID buffer);
-
- GUID provider_name_;
- TRACEHANDLE registration_handle_;
- TRACEHANDLE session_handle_;
- EtwEventFlags enable_flags_;
- EtwEventLevel enable_level_;
-
- // We don't use this, but on XP we're obliged to pass one in to
- // RegisterTraceGuids. Non-const, because that's how the API needs it.
- static TRACE_GUID_REGISTRATION obligatory_guid_registration_;
-
- DISALLOW_COPY_AND_ASSIGN(EtwTraceProvider);
-};
-
-} // namespace win
-} // namespace base
-
-#endif // BASE_WIN_EVENT_TRACE_PROVIDER_H_
diff --git a/base/win/iat_patch_function.cc b/base/win/iat_patch_function.cc
index 3cc747b..5f151f9 100644
--- a/base/win/iat_patch_function.cc
+++ b/base/win/iat_patch_function.cc
@@ -42,11 +42,15 @@
return iat_function.pointer;
}
-bool InterceptEnumCallback(const base::win::PEImage& image, const char* module,
- DWORD ordinal, const char* name, DWORD hint,
- IMAGE_THUNK_DATA* iat, void* cookie) {
+bool InterceptEnumCallback(const base::win::PEImage& image,
+ const char* module,
+ DWORD ordinal,
+ const char* name,
+ DWORD hint,
+ IMAGE_THUNK_DATA* iat,
+ void* cookie) {
InterceptFunctionInformation* intercept_information =
- reinterpret_cast<InterceptFunctionInformation*>(cookie);
+ reinterpret_cast<InterceptFunctionInformation*>(cookie);
if (NULL == intercept_information) {
NOTREACHED();
@@ -56,8 +60,8 @@
DCHECK(module);
if ((0 == lstrcmpiA(module, intercept_information->imported_from_module)) &&
- (NULL != name) &&
- (0 == lstrcmpiA(name, intercept_information->function_name))) {
+ (NULL != name) &&
+ (0 == lstrcmpiA(name, intercept_information->function_name))) {
// Save the old pointer.
if (NULL != intercept_information->old_function) {
*(intercept_information->old_function) = GetIATFunction(iat);
@@ -101,11 +105,12 @@
// as defined in winerror.h
DWORD InterceptImportedFunction(HMODULE module_handle,
const char* imported_from_module,
- const char* function_name, void* new_function,
+ const char* function_name,
+ void* new_function,
void** old_function,
IMAGE_THUNK_DATA** iat_thunk) {
if ((NULL == module_handle) || (NULL == imported_from_module) ||
- (NULL == function_name) || (NULL == new_function)) {
+ (NULL == function_name) || (NULL == new_function)) {
NOTREACHED();
return ERROR_INVALID_PARAMETER;
}
@@ -116,14 +121,13 @@
return ERROR_INVALID_PARAMETER;
}
- InterceptFunctionInformation intercept_information = {
- false,
- imported_from_module,
- function_name,
- new_function,
- old_function,
- iat_thunk,
- ERROR_GEN_FAILURE};
+ InterceptFunctionInformation intercept_information = {false,
+ imported_from_module,
+ function_name,
+ new_function,
+ old_function,
+ iat_thunk,
+ ERROR_GEN_FAILURE};
// First go through the IAT. If we don't find the import we are looking
// for in IAT, search delay import table.
@@ -170,8 +174,7 @@
: module_handle_(NULL),
intercept_function_(NULL),
original_function_(NULL),
- iat_thunk_(NULL) {
-}
+ iat_thunk_(NULL) {}
IATPatchFunction::~IATPatchFunction() {
if (NULL != intercept_function_) {
@@ -210,12 +213,9 @@
DCHECK_EQ(static_cast<void*>(NULL), intercept_function_);
DCHECK(module);
- DWORD error = InterceptImportedFunction(module,
- imported_from_module,
- function_name,
- new_function,
- &original_function_,
- &iat_thunk_);
+ DWORD error =
+ InterceptImportedFunction(module, imported_from_module, function_name,
+ new_function, &original_function_, &iat_thunk_);
if (NO_ERROR == error) {
DCHECK_NE(original_function_, intercept_function_);
@@ -226,8 +226,7 @@
}
DWORD IATPatchFunction::Unpatch() {
- DWORD error = RestoreImportedFunction(intercept_function_,
- original_function_,
+ DWORD error = RestoreImportedFunction(intercept_function_, original_function_,
iat_thunk_);
DCHECK_EQ(static_cast<DWORD>(NO_ERROR), error);
diff --git a/base/win/iat_patch_function.h b/base/win/iat_patch_function.h
index 30f0ab9..c9f2d6c 100644
--- a/base/win/iat_patch_function.h
+++ b/base/win/iat_patch_function.h
@@ -58,13 +58,10 @@
// Returns: Windows error code (winerror.h). NO_ERROR if successful
DWORD Unpatch();
- bool is_patched() const {
- return (NULL != intercept_function_);
- }
+ bool is_patched() const { return (NULL != intercept_function_); }
void* original_function() const;
-
private:
HMODULE module_handle_;
void* intercept_function_;
diff --git a/base/win/iunknown_impl.cc b/base/win/iunknown_impl.cc
index 2a88439..2d83523 100644
--- a/base/win/iunknown_impl.cc
+++ b/base/win/iunknown_impl.cc
@@ -7,12 +7,9 @@
namespace base {
namespace win {
-IUnknownImpl::IUnknownImpl()
- : ref_count_(0) {
-}
+IUnknownImpl::IUnknownImpl() : ref_count_(0) {}
-IUnknownImpl::~IUnknownImpl() {
-}
+IUnknownImpl::~IUnknownImpl() {}
ULONG STDMETHODCALLTYPE IUnknownImpl::AddRef() {
ref_count_.Increment();
diff --git a/base/win/patch_util.cc b/base/win/patch_util.cc
index eb3bd65..c53a8e4 100644
--- a/base/win/patch_util.cc
+++ b/base/win/patch_util.cc
@@ -49,4 +49,4 @@
} // namespace internal
} // namespace win
-} // namespace bsae
+} // namespace base
diff --git a/base/win/patch_util.h b/base/win/patch_util.h
index 02ac72c..6668273 100644
--- a/base/win/patch_util.h
+++ b/base/win/patch_util.h
@@ -7,7 +7,6 @@
#include <windows.h>
-
namespace base {
namespace win {
namespace internal {
@@ -19,6 +18,6 @@
} // namespace internal
} // namespace win
-} // namespace bsae
+} // namespace base
#endif // BASE_WIN_PATCH_UTIL_H_
diff --git a/base/win/pe_image.cc b/base/win/pe_image.cc
index 4705348..ea58504 100644
--- a/base/win/pe_image.cc
+++ b/base/win/pe_image.cc
@@ -48,9 +48,11 @@
} // namespace
// Callback used to enumerate imports. See EnumImportChunksFunction.
-bool ProcessImportChunk(const PEImage &image, LPCSTR module,
+bool ProcessImportChunk(const PEImage& image,
+ LPCSTR module,
PIMAGE_THUNK_DATA name_table,
- PIMAGE_THUNK_DATA iat, PVOID cookie) {
+ PIMAGE_THUNK_DATA iat,
+ PVOID cookie) {
EnumAllImportsStorage& storage =
*reinterpret_cast<EnumAllImportsStorage*>(cookie);
@@ -120,8 +122,8 @@
for (UINT i = 0; NULL != (section = GetSectionHeader(i)); i++) {
// Don't use the virtual RVAToAddr.
- PBYTE start = reinterpret_cast<PBYTE>(
- PEImage::RVAToAddr(section->VirtualAddress));
+ PBYTE start =
+ reinterpret_cast<PBYTE>(PEImage::RVAToAddr(section->VirtualAddress));
DWORD size = section->Misc.VirtualSize;
@@ -157,10 +159,9 @@
GetImageDirectoryEntrySize(IMAGE_DIRECTORY_ENTRY_DEBUG);
PIMAGE_DEBUG_DIRECTORY debug_directory =
reinterpret_cast<PIMAGE_DEBUG_DIRECTORY>(
- GetImageDirectoryEntryAddr(IMAGE_DIRECTORY_ENTRY_DEBUG));
+ GetImageDirectoryEntryAddr(IMAGE_DIRECTORY_ENTRY_DEBUG));
- size_t directory_count =
- debug_directory_size / sizeof(IMAGE_DEBUG_DIRECTORY);
+ size_t directory_count = debug_directory_size / sizeof(IMAGE_DEBUG_DIRECTORY);
for (size_t index = 0; index < directory_count; ++index) {
if (debug_directory[index].Type == IMAGE_DEBUG_TYPE_CODEVIEW) {
@@ -193,8 +194,8 @@
if (!GetProcOrdinal(name, &ordinal))
return NULL;
- PDWORD functions = reinterpret_cast<PDWORD>(
- RVAToAddr(exports->AddressOfFunctions));
+ PDWORD functions =
+ reinterpret_cast<PDWORD>(RVAToAddr(exports->AddressOfFunctions));
return functions + ordinal - exports->Base;
}
@@ -217,7 +218,7 @@
return reinterpret_cast<FARPROC>(function);
}
-bool PEImage::GetProcOrdinal(LPCSTR function_name, WORD *ordinal) const {
+bool PEImage::GetProcOrdinal(LPCSTR function_name, WORD* ordinal) const {
if (NULL == ordinal)
return false;
@@ -257,9 +258,8 @@
if (cmp != 0)
return false;
-
- PWORD ordinals = reinterpret_cast<PWORD>(
- RVAToAddr(exports->AddressOfNameOrdinals));
+ PWORD ordinals =
+ reinterpret_cast<PWORD>(RVAToAddr(exports->AddressOfNameOrdinals));
*ordinal = ordinals[lower - names] + static_cast<WORD>(exports->Base);
}
@@ -291,16 +291,16 @@
if (NULL == directory || 0 == size)
return true;
- PIMAGE_EXPORT_DIRECTORY exports = reinterpret_cast<PIMAGE_EXPORT_DIRECTORY>(
- directory);
+ PIMAGE_EXPORT_DIRECTORY exports =
+ reinterpret_cast<PIMAGE_EXPORT_DIRECTORY>(directory);
UINT ordinal_base = exports->Base;
UINT num_funcs = exports->NumberOfFunctions;
UINT num_names = exports->NumberOfNames;
- PDWORD functions = reinterpret_cast<PDWORD>(RVAToAddr(
- exports->AddressOfFunctions));
+ PDWORD functions =
+ reinterpret_cast<PDWORD>(RVAToAddr(exports->AddressOfFunctions));
PDWORD names = reinterpret_cast<PDWORD>(RVAToAddr(exports->AddressOfNames));
- PWORD ordinals = reinterpret_cast<PWORD>(RVAToAddr(
- exports->AddressOfNameOrdinals));
+ PWORD ordinals =
+ reinterpret_cast<PWORD>(RVAToAddr(exports->AddressOfNameOrdinals));
for (UINT count = 0; count < num_funcs; count++) {
PVOID func = RVAToAddr(functions[count]);
@@ -323,8 +323,8 @@
// Check for forwarded exports.
LPCSTR forward = NULL;
if (reinterpret_cast<char*>(func) >= reinterpret_cast<char*>(directory) &&
- reinterpret_cast<char*>(func) <= reinterpret_cast<char*>(directory) +
- size) {
+ reinterpret_cast<char*>(func) <=
+ reinterpret_cast<char*>(directory) + size) {
forward = reinterpret_cast<LPCSTR>(func);
func = 0;
}
@@ -340,8 +340,8 @@
bool PEImage::EnumRelocs(EnumRelocsFunction callback, PVOID cookie) const {
PVOID directory = GetImageDirectoryEntryAddr(IMAGE_DIRECTORY_ENTRY_BASERELOC);
DWORD size = GetImageDirectoryEntrySize(IMAGE_DIRECTORY_ENTRY_BASERELOC);
- PIMAGE_BASE_RELOCATION base = reinterpret_cast<PIMAGE_BASE_RELOCATION>(
- directory);
+ PIMAGE_BASE_RELOCATION base =
+ reinterpret_cast<PIMAGE_BASE_RELOCATION>(directory);
if (!directory)
return true;
@@ -349,8 +349,8 @@
while (size >= sizeof(IMAGE_BASE_RELOCATION) && base->SizeOfBlock &&
size >= base->SizeOfBlock) {
PWORD reloc = reinterpret_cast<PWORD>(base + 1);
- UINT num_relocs = (base->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) /
- sizeof(WORD);
+ UINT num_relocs =
+ (base->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
for (UINT i = 0; i < num_relocs; i++, reloc++) {
WORD type = *reloc >> 12;
@@ -362,7 +362,7 @@
size -= base->SizeOfBlock;
base = reinterpret_cast<PIMAGE_BASE_RELOCATION>(
- reinterpret_cast<char*>(base) + base->SizeOfBlock);
+ reinterpret_cast<char*>(base) + base->SizeOfBlock);
}
return true;
@@ -379,9 +379,9 @@
for (; import->FirstThunk; import++) {
LPCSTR module_name = reinterpret_cast<LPCSTR>(RVAToAddr(import->Name));
PIMAGE_THUNK_DATA name_table = reinterpret_cast<PIMAGE_THUNK_DATA>(
- RVAToAddr(import->OriginalFirstThunk));
- PIMAGE_THUNK_DATA iat = reinterpret_cast<PIMAGE_THUNK_DATA>(
- RVAToAddr(import->FirstThunk));
+ RVAToAddr(import->OriginalFirstThunk));
+ PIMAGE_THUNK_DATA iat =
+ reinterpret_cast<PIMAGE_THUNK_DATA>(RVAToAddr(import->FirstThunk));
if (!callback(*this, module_name, name_table, iat, cookie))
return false;
@@ -393,7 +393,8 @@
bool PEImage::EnumOneImportChunk(EnumImportsFunction callback,
LPCSTR module_name,
PIMAGE_THUNK_DATA name_table,
- PIMAGE_THUNK_DATA iat, PVOID cookie) const {
+ PIMAGE_THUNK_DATA iat,
+ PVOID cookie) const {
if (NULL == name_table)
return false;
@@ -420,14 +421,14 @@
}
bool PEImage::EnumAllImports(EnumImportsFunction callback, PVOID cookie) const {
- EnumAllImportsStorage temp = { callback, cookie };
+ EnumAllImportsStorage temp = {callback, cookie};
return EnumImportChunks(ProcessImportChunk, &temp);
}
bool PEImage::EnumDelayImportChunks(EnumDelayImportChunksFunction callback,
PVOID cookie) const {
- PVOID directory = GetImageDirectoryEntryAddr(
- IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT);
+ PVOID directory =
+ GetImageDirectoryEntryAddr(IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT);
DWORD size = GetImageDirectoryEntrySize(IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT);
PImgDelayDescr delay_descriptor = reinterpret_cast<PImgDelayDescr>(directory);
@@ -488,10 +489,10 @@
if (rvas) {
import = reinterpret_cast<PIMAGE_IMPORT_BY_NAME>(
- RVAToAddr(name_table->u1.ForwarderString));
+ RVAToAddr(name_table->u1.ForwarderString));
} else {
import = reinterpret_cast<PIMAGE_IMPORT_BY_NAME>(
- name_table->u1.ForwarderString);
+ name_table->u1.ForwarderString);
}
hint = import->Hint;
@@ -507,7 +508,7 @@
bool PEImage::EnumAllDelayImports(EnumImportsFunction callback,
PVOID cookie) const {
- EnumAllImportsStorage temp = { callback, cookie };
+ EnumAllImportsStorage temp = {callback, cookie};
return EnumDelayImportChunks(ProcessDelayImportChunk, &temp);
}
diff --git a/base/win/pe_image.h b/base/win/pe_image.h
index 3f8f868..7766b49 100644
--- a/base/win/pe_image.h
+++ b/base/win/pe_image.h
@@ -30,9 +30,10 @@
// Callback to enumerate sections.
// cookie is the value passed to the enumerate method.
// Returns true to continue the enumeration.
- typedef bool (*EnumSectionsFunction)(const PEImage &image,
+ typedef bool (*EnumSectionsFunction)(const PEImage& image,
PIMAGE_SECTION_HEADER header,
- PVOID section_start, DWORD section_size,
+ PVOID section_start,
+ DWORD section_size,
PVOID cookie);
// Callback to enumerate exports.
@@ -40,31 +41,41 @@
// contains the dll and symbol to forward this export to. cookie is the value
// passed to the enumerate method.
// Returns true to continue the enumeration.
- typedef bool (*EnumExportsFunction)(const PEImage &image, DWORD ordinal,
- DWORD hint, LPCSTR name, PVOID function,
- LPCSTR forward, PVOID cookie);
+ typedef bool (*EnumExportsFunction)(const PEImage& image,
+ DWORD ordinal,
+ DWORD hint,
+ LPCSTR name,
+ PVOID function,
+ LPCSTR forward,
+ PVOID cookie);
// Callback to enumerate import blocks.
// name_table and iat point to the imports name table and address table for
// this block. cookie is the value passed to the enumerate method.
// Returns true to continue the enumeration.
- typedef bool (*EnumImportChunksFunction)(const PEImage &image, LPCSTR module,
+ typedef bool (*EnumImportChunksFunction)(const PEImage& image,
+ LPCSTR module,
PIMAGE_THUNK_DATA name_table,
- PIMAGE_THUNK_DATA iat, PVOID cookie);
+ PIMAGE_THUNK_DATA iat,
+ PVOID cookie);
// Callback to enumerate imports.
// module is the dll that exports this symbol. cookie is the value passed to
// the enumerate method.
// Returns true to continue the enumeration.
- typedef bool (*EnumImportsFunction)(const PEImage &image, LPCSTR module,
- DWORD ordinal, LPCSTR name, DWORD hint,
- PIMAGE_THUNK_DATA iat, PVOID cookie);
+ typedef bool (*EnumImportsFunction)(const PEImage& image,
+ LPCSTR module,
+ DWORD ordinal,
+ LPCSTR name,
+ DWORD hint,
+ PIMAGE_THUNK_DATA iat,
+ PVOID cookie);
// Callback to enumerate delayed import blocks.
// module is the dll that exports this block of symbols. cookie is the value
// passed to the enumerate method.
// Returns true to continue the enumeration.
- typedef bool (*EnumDelayImportChunksFunction)(const PEImage &image,
+ typedef bool (*EnumDelayImportChunksFunction)(const PEImage& image,
PImgDelayDescr delay_descriptor,
LPCSTR module,
PIMAGE_THUNK_DATA name_table,
@@ -74,8 +85,10 @@
// Callback to enumerate relocations.
// cookie is the value passed to the enumerate method.
// Returns true to continue the enumeration.
- typedef bool (*EnumRelocsFunction)(const PEImage &image, WORD type,
- PVOID address, PVOID cookie);
+ typedef bool (*EnumRelocsFunction)(const PEImage& image,
+ WORD type,
+ PVOID address,
+ PVOID cookie);
explicit PEImage(HMODULE module) : module_(module) {}
explicit PEImage(const void* module) {
@@ -155,7 +168,7 @@
// Retrieves the ordinal for a given exported symbol.
// Returns true if the symbol was found.
- bool GetProcOrdinal(LPCSTR function_name, WORD *ordinal) const;
+ bool GetProcOrdinal(LPCSTR function_name, WORD* ordinal) const;
// Enumerates PE sections.
// cookie is a generic cookie to pass to the callback.
@@ -180,11 +193,12 @@
// Enumerates the imports from a single PE import block.
// cookie is a generic cookie to pass to the callback.
// Returns true on success.
- bool EnumOneImportChunk(EnumImportsFunction callback, LPCSTR module_name,
- PIMAGE_THUNK_DATA name_table, PIMAGE_THUNK_DATA iat,
+ bool EnumOneImportChunk(EnumImportsFunction callback,
+ LPCSTR module_name,
+ PIMAGE_THUNK_DATA name_table,
+ PIMAGE_THUNK_DATA iat,
PVOID cookie) const;
-
// Enumerates PE delay imports.
// cookie is a generic cookie to pass to the callback.
// Returns true on success.
@@ -220,11 +234,11 @@
// Converts an rva value to an offset on disk.
// Returns true on success.
- bool ImageRVAToOnDiskOffset(DWORD rva, DWORD *on_disk_offset) const;
+ bool ImageRVAToOnDiskOffset(DWORD rva, DWORD* on_disk_offset) const;
// Converts an address to an offset on disk.
// Returns true on success.
- bool ImageAddrToOnDiskOffset(LPVOID address, DWORD *on_disk_offset) const;
+ bool ImageAddrToOnDiskOffset(LPVOID address, DWORD* on_disk_offset) const;
private:
HMODULE module_;
@@ -253,12 +267,12 @@
inline PIMAGE_IMPORT_DESCRIPTOR PEImage::GetFirstImportChunk() const {
return reinterpret_cast<PIMAGE_IMPORT_DESCRIPTOR>(
- GetImageDirectoryEntryAddr(IMAGE_DIRECTORY_ENTRY_IMPORT));
+ GetImageDirectoryEntryAddr(IMAGE_DIRECTORY_ENTRY_IMPORT));
}
inline PIMAGE_EXPORT_DIRECTORY PEImage::GetExportDirectory() const {
return reinterpret_cast<PIMAGE_EXPORT_DIRECTORY>(
- GetImageDirectoryEntryAddr(IMAGE_DIRECTORY_ENTRY_EXPORT));
+ GetImageDirectoryEntryAddr(IMAGE_DIRECTORY_ENTRY_EXPORT));
}
} // namespace win
diff --git a/base/win/process_startup_helper.cc b/base/win/process_startup_helper.cc
index de44b2a..347db71 100644
--- a/base/win/process_startup_helper.cc
+++ b/base/win/process_startup_helper.cc
@@ -13,8 +13,10 @@
#pragma optimize("", off)
// Handlers for invalid parameter and pure call. They generate a breakpoint to
// tell breakpad that it needs to dump the process.
-void InvalidParameter(const wchar_t* expression, const wchar_t* function,
- const wchar_t* file, unsigned int line,
+void InvalidParameter(const wchar_t* expression,
+ const wchar_t* function,
+ const wchar_t* file,
+ unsigned int line,
uintptr_t reserved) {
__debugbreak();
_exit(1);
diff --git a/base/win/process_startup_helper.h b/base/win/process_startup_helper.h
index 2f19ac9..c579433 100644
--- a/base/win/process_startup_helper.h
+++ b/base/win/process_startup_helper.h
@@ -5,7 +5,6 @@
#ifndef BASE_WIN_PROCESS_STARTUP_HELPER_H_
#define BASE_WIN_PROCESS_STARTUP_HELPER_H_
-
namespace base {
class CommandLine;
diff --git a/base/win/registry.cc b/base/win/registry.cc
index 3de51e3..1ca839d 100644
--- a/base/win/registry.cc
+++ b/base/win/registry.cc
@@ -37,15 +37,12 @@
// RegKey ----------------------------------------------------------------------
-RegKey::RegKey() : key_(NULL), wow64access_(0) {
-}
+RegKey::RegKey() : key_(NULL), wow64access_(0) {}
-RegKey::RegKey(HKEY key) : key_(key), wow64access_(0) {
-}
+RegKey::RegKey(HKEY key) : key_(key), wow64access_(0) {}
RegKey::RegKey(HKEY rootkey, const wchar_t* subkey, REGSAM access)
- : key_(NULL),
- wow64access_(0) {
+ : key_(NULL), wow64access_(0) {
if (rootkey) {
if (access & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_CREATE_LINK))
Create(rootkey, subkey, access);
@@ -66,13 +63,15 @@
return CreateWithDisposition(rootkey, subkey, &disposition_value, access);
}
-LONG RegKey::CreateWithDisposition(HKEY rootkey, const wchar_t* subkey,
- DWORD* disposition, REGSAM access) {
+LONG RegKey::CreateWithDisposition(HKEY rootkey,
+ const wchar_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, subkey, 0, NULL, REG_OPTION_NON_VOLATILE, access,
+ NULL, &subhkey, disposition);
if (result == ERROR_SUCCESS) {
Close();
key_ = subhkey;
@@ -208,8 +207,8 @@
DCHECK(name);
HKEY target_key = NULL;
- LONG result = RegOpenKeyEx(key_, name, 0, KEY_READ | wow64access_,
- &target_key);
+ LONG result =
+ RegOpenKeyEx(key_, name, 0, KEY_READ | wow64access_, &target_key);
if (result != ERROR_SUCCESS)
return result;
@@ -339,12 +338,13 @@
}
LONG RegKey::WriteValue(const wchar_t* name, DWORD in_value) {
- return WriteValue(
- name, &in_value, static_cast<DWORD>(sizeof(in_value)), REG_DWORD);
+ 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) {
- return WriteValue(name, in_value,
+LONG RegKey::WriteValue(const wchar_t* name, const wchar_t* in_value) {
+ return WriteValue(
+ name, in_value,
static_cast<DWORD>(sizeof(*in_value) * (wcslen(in_value) + 1)), REG_SZ);
}
@@ -354,8 +354,9 @@
DWORD dtype) {
DCHECK(data || !dsize);
- LONG result = RegSetValueEx(key_, name, 0, dtype,
- reinterpret_cast<LPBYTE>(const_cast<void*>(data)), dsize);
+ LONG result =
+ RegSetValueEx(key_, name, 0, dtype,
+ reinterpret_cast<LPBYTE>(const_cast<void*>(data)), dsize);
return result;
}
@@ -364,7 +365,7 @@
const wchar_t* lpSubKey,
REGSAM samDesired,
DWORD Reserved) {
- typedef LSTATUS(WINAPI* RegDeleteKeyExPtr)(HKEY, LPCWSTR, REGSAM, DWORD);
+ typedef LSTATUS(WINAPI * RegDeleteKeyExPtr)(HKEY, LPCWSTR, REGSAM, DWORD);
RegDeleteKeyExPtr reg_delete_key_ex_func =
reinterpret_cast<RegDeleteKeyExPtr>(
@@ -387,8 +388,8 @@
return result;
HKEY target_key = NULL;
- result = RegOpenKeyEx(
- root_key, name.c_str(), 0, KEY_ENUMERATE_SUB_KEYS | access, &target_key);
+ result = RegOpenKeyEx(root_key, name.c_str(), 0,
+ KEY_ENUMERATE_SUB_KEYS | access, &target_key);
if (result == ERROR_FILE_NOT_FOUND)
return ERROR_SUCCESS;
@@ -408,14 +409,9 @@
std::wstring 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, WriteInto(&key_name, kMaxKeyNameLength),
+ &key_size, NULL, NULL, NULL, NULL);
if (result != ERROR_SUCCESS)
break;
@@ -441,15 +437,13 @@
RegistryValueIterator::RegistryValueIterator(HKEY root_key,
const wchar_t* folder_key,
REGSAM wow64access)
- : name_(MAX_PATH, L'\0'),
- value_(MAX_PATH, L'\0') {
+ : 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)
- : name_(MAX_PATH, L'\0'),
- value_(MAX_PATH, L'\0') {
+ : name_(MAX_PATH, L'\0'), value_(MAX_PATH, L'\0') {
Initialize(root_key, folder_key, 0);
}
@@ -484,8 +478,8 @@
DWORD RegistryValueIterator::ValueCount() const {
DWORD count = 0;
- LONG result = ::RegQueryInfoKey(key_, NULL, 0, NULL, NULL, NULL, NULL,
- &count, NULL, NULL, NULL, NULL);
+ LONG result = ::RegQueryInfoKey(key_, NULL, 0, NULL, NULL, NULL, NULL, &count,
+ NULL, NULL, NULL, NULL);
if (result != ERROR_SUCCESS)
return 0;
@@ -561,8 +555,8 @@
DWORD RegistryKeyIterator::SubkeyCount() const {
DWORD count = 0;
- LONG result = ::RegQueryInfoKey(key_, NULL, 0, NULL, &count, NULL, NULL,
- NULL, NULL, NULL, NULL, NULL);
+ LONG result = ::RegQueryInfoKey(key_, NULL, 0, NULL, &count, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL);
if (result != ERROR_SUCCESS)
return 0;
@@ -582,8 +576,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_, name_, &ncount, NULL, NULL, NULL,
+ &written);
if (ERROR_SUCCESS == r)
return true;
}
diff --git a/base/win/registry.h b/base/win/registry.h
index 413ee7a..e2e0d30 100644
--- a/base/win/registry.h
+++ b/base/win/registry.h
@@ -34,8 +34,10 @@
LONG Create(HKEY rootkey, const wchar_t* subkey, REGSAM access);
- LONG CreateWithDisposition(HKEY rootkey, const wchar_t* subkey,
- DWORD* disposition, REGSAM access);
+ LONG CreateWithDisposition(HKEY rootkey,
+ const wchar_t* subkey,
+ DWORD* disposition,
+ REGSAM access);
// Creates a subkey or open it if it already exists.
LONG CreateKey(const wchar_t* name, REGSAM access);
diff --git a/base/win/resource_util.cc b/base/win/resource_util.cc
index 0c10078..b964aee 100644
--- a/base/win/resource_util.cc
+++ b/base/win/resource_util.cc
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "base/logging.h"
#include "base/win/resource_util.h"
+#include "base/logging.h"
namespace base {
namespace win {
@@ -21,8 +21,8 @@
return false;
}
- HRSRC hres_info = FindResource(module, MAKEINTRESOURCE(resource_id),
- resource_type);
+ HRSRC hres_info =
+ FindResource(module, MAKEINTRESOURCE(resource_id), resource_type);
if (NULL == hres_info)
return false;
diff --git a/base/win/resource_util.h b/base/win/resource_util.h
index 3e6b145..b4473fd 100644
--- a/base/win/resource_util.h
+++ b/base/win/resource_util.h
@@ -8,9 +8,8 @@
#ifndef BASE_WIN_RESOURCE_UTIL_H_
#define BASE_WIN_RESOURCE_UTIL_H_
-#include <windows.h>
#include <stddef.h>
-
+#include <windows.h>
namespace base {
namespace win {
@@ -19,18 +18,18 @@
// a dll. Some resources are optional, especially in unit tests, so this
// returns false but doesn't raise an error if the resource can't be loaded.
bool GetResourceFromModule(HMODULE module,
- int resource_id,
- LPCTSTR resource_type,
- void** data,
- size_t* length);
+ int resource_id,
+ LPCTSTR resource_type,
+ void** data,
+ size_t* length);
// Function for getting a data resource (BINDATA) from a dll. Some
// resources are optional, especially in unit tests, so this returns false
// but doesn't raise an error if the resource can't be loaded.
bool GetDataResourceFromModule(HMODULE module,
- int resource_id,
- void** data,
- size_t* length);
+ int resource_id,
+ void** data,
+ size_t* length);
} // namespace win
} // namespace base
diff --git a/base/win/scoped_bstr.cc b/base/win/scoped_bstr.cc
deleted file mode 100644
index 02f3d54..0000000
--- a/base/win/scoped_bstr.cc
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (c) 2010 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/win/scoped_bstr.h"
-
-#include <stdint.h>
-
-#include "base/logging.h"
-
-namespace base {
-namespace win {
-
-ScopedBstr::ScopedBstr(const char16* non_bstr)
- : bstr_(SysAllocString(non_bstr)) {
-}
-
-ScopedBstr::~ScopedBstr() {
- static_assert(sizeof(ScopedBstr) == sizeof(BSTR), "ScopedBstrSize");
- SysFreeString(bstr_);
-}
-
-void ScopedBstr::Reset(BSTR bstr) {
- if (bstr != bstr_) {
- // if |bstr_| is NULL, SysFreeString does nothing.
- SysFreeString(bstr_);
- bstr_ = bstr;
- }
-}
-
-BSTR ScopedBstr::Release() {
- BSTR bstr = bstr_;
- bstr_ = NULL;
- return bstr;
-}
-
-void ScopedBstr::Swap(ScopedBstr& bstr2) {
- BSTR tmp = bstr_;
- bstr_ = bstr2.bstr_;
- bstr2.bstr_ = tmp;
-}
-
-BSTR* ScopedBstr::Receive() {
- DCHECK(!bstr_) << "BSTR leak.";
- return &bstr_;
-}
-
-BSTR ScopedBstr::Allocate(const char16* str) {
- Reset(SysAllocString(str));
- return bstr_;
-}
-
-BSTR ScopedBstr::AllocateBytes(size_t bytes) {
- Reset(SysAllocStringByteLen(NULL, static_cast<UINT>(bytes)));
- return bstr_;
-}
-
-void ScopedBstr::SetByteLen(size_t bytes) {
- DCHECK(bstr_ != NULL) << "attempting to modify a NULL bstr";
- uint32_t* data = reinterpret_cast<uint32_t*>(bstr_);
- data[-1] = static_cast<uint32_t>(bytes);
-}
-
-size_t ScopedBstr::Length() const {
- return SysStringLen(bstr_);
-}
-
-size_t ScopedBstr::ByteLength() const {
- return SysStringByteLen(bstr_);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/scoped_bstr.h b/base/win/scoped_bstr.h
deleted file mode 100644
index 02f73ed..0000000
--- a/base/win/scoped_bstr.h
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright (c) 2011 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_SCOPED_BSTR_H_
-#define BASE_WIN_SCOPED_BSTR_H_
-
-#include <windows.h>
-#include <oleauto.h>
-#include <stddef.h>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string16.h"
-
-namespace base {
-namespace win {
-
-// Manages a BSTR string pointer.
-// The class interface is based on unique_ptr.
-class ScopedBstr {
- public:
- ScopedBstr() : bstr_(NULL) {
- }
-
- // Constructor to create a new BSTR.
- //
- // NOTE: Do not pass a BSTR to this constructor expecting ownership to
- // be transferred - even though it compiles! ;-)
- explicit ScopedBstr(const char16* non_bstr);
- ~ScopedBstr();
-
- // Give ScopedBstr ownership over an already allocated BSTR or NULL.
- // If you need to allocate a new BSTR instance, use |allocate| instead.
- void Reset(BSTR bstr = NULL);
-
- // Releases ownership of the BSTR to the caller.
- BSTR Release();
-
- // Creates a new BSTR from a 16-bit C-style string.
- //
- // If you already have a BSTR and want to transfer ownership to the
- // ScopedBstr instance, call |reset| instead.
- //
- // Returns a pointer to the new BSTR, or NULL if allocation failed.
- BSTR Allocate(const char16* str);
-
- // Allocates a new BSTR with the specified number of bytes.
- // Returns a pointer to the new BSTR, or NULL if allocation failed.
- BSTR AllocateBytes(size_t bytes);
-
- // Sets the allocated length field of the already-allocated BSTR to be
- // |bytes|. This is useful when the BSTR was preallocated with e.g.
- // SysAllocStringLen or SysAllocStringByteLen (call |AllocateBytes|) and then
- // not all the bytes are being used.
- //
- // Note that if you want to set the length to a specific number of
- // characters, you need to multiply by sizeof(wchar_t). Oddly, there's no
- // public API to set the length, so we do this ourselves by hand.
- //
- // NOTE: The actual allocated size of the BSTR MUST be >= bytes. That
- // responsibility is with the caller.
- void SetByteLen(size_t bytes);
-
- // Swap values of two ScopedBstr's.
- void Swap(ScopedBstr& bstr2);
-
- // Retrieves the pointer address.
- // Used to receive BSTRs as out arguments (and take ownership).
- // The function DCHECKs on the current value being NULL.
- // Usage: GetBstr(bstr.Receive());
- BSTR* Receive();
-
- // Returns number of chars in the BSTR.
- size_t Length() const;
-
- // Returns the number of bytes allocated for the BSTR.
- size_t ByteLength() const;
-
- operator BSTR() const {
- return bstr_;
- }
-
- protected:
- BSTR bstr_;
-
- private:
- // Forbid comparison of ScopedBstr types. You should never have the same
- // BSTR owned by two different scoped_ptrs.
- bool operator==(const ScopedBstr& bstr2) const;
- bool operator!=(const ScopedBstr& bstr2) const;
- DISALLOW_COPY_AND_ASSIGN(ScopedBstr);
-};
-
-} // namespace win
-} // namespace base
-
-#endif // BASE_WIN_SCOPED_BSTR_H_
diff --git a/base/win/scoped_co_mem.h b/base/win/scoped_co_mem.h
index a3737dd..3c31f3f 100644
--- a/base/win/scoped_co_mem.h
+++ b/base/win/scoped_co_mem.h
@@ -19,22 +19,18 @@
// SHGetSomeInfo(&file_item, ...);
// ...
// return; <-- memory released
-template<typename T>
+template <typename T>
class ScopedCoMem {
public:
ScopedCoMem() : mem_ptr_(NULL) {}
- ~ScopedCoMem() {
- Reset(NULL);
- }
+ ~ScopedCoMem() { Reset(NULL); }
- T** operator&() { // NOLINT
+ T** operator&() { // NOLINT
DCHECK(mem_ptr_ == NULL); // To catch memory leaks.
return &mem_ptr_;
}
- operator T*() {
- return mem_ptr_;
- }
+ operator T*() { return mem_ptr_; }
T* operator->() {
DCHECK(mem_ptr_ != NULL);
@@ -52,9 +48,7 @@
mem_ptr_ = ptr;
}
- T* get() const {
- return mem_ptr_;
- }
+ T* get() const { return mem_ptr_; }
private:
T* mem_ptr_;
diff --git a/base/win/scoped_handle.cc b/base/win/scoped_handle.cc
index b47183e..ddc744f 100644
--- a/base/win/scoped_handle.cc
+++ b/base/win/scoped_handle.cc
@@ -16,20 +16,20 @@
}
// Static.
-void VerifierTraits::StartTracking(HANDLE handle, const void* owner,
- const void* pc1, const void* pc2) {
-}
+void VerifierTraits::StartTracking(HANDLE handle,
+ const void* owner,
+ const void* pc1,
+ const void* pc2) {}
// Static.
-void VerifierTraits::StopTracking(HANDLE handle, const void* owner,
- const void* pc1, const void* pc2) {
-}
+void VerifierTraits::StopTracking(HANDLE handle,
+ const void* owner,
+ const void* pc1,
+ const void* pc2) {}
-void DisableHandleVerifier() {
-}
+void DisableHandleVerifier() {}
-void OnHandleBeingClosed(HANDLE handle) {
-}
+void OnHandleBeingClosed(HANDLE handle) {}
} // namespace win
} // namespace base
diff --git a/base/win/scoped_handle.h b/base/win/scoped_handle.h
index 7c63bb7..e67e447 100644
--- a/base/win/scoped_handle.h
+++ b/base/win/scoped_handle.h
@@ -16,8 +16,8 @@
#include <intrin.h>
#define BASE_WIN_GET_CALLER _ReturnAddress()
#elif defined(COMPILER_GCC)
-#define BASE_WIN_GET_CALLER __builtin_extract_return_addr(\\
- __builtin_return_address(0))
+#define BASE_WIN_GET_CALLER \
+ __builtin_extract_return_addr(\ __builtin_return_address(0))
#endif
namespace base {
@@ -48,13 +48,9 @@
Set(other.Take());
}
- ~GenericScopedHandle() {
- Close();
- }
+ ~GenericScopedHandle() { Close(); }
- bool IsValid() const {
- return Traits::IsHandleValid(handle_);
- }
+ bool IsValid() const { return Traits::IsHandleValid(handle_); }
GenericScopedHandle& operator=(GenericScopedHandle&& other) {
DCHECK_NE(this, &other);
@@ -75,9 +71,7 @@
}
}
- Handle Get() const {
- return handle_;
- }
+ Handle Get() const { return handle_; }
// Transfers ownership away from this object.
Handle Take() {
@@ -118,9 +112,7 @@
}
// Returns NULL handle value.
- static HANDLE NullHandle() {
- return NULL;
- }
+ static HANDLE NullHandle() { return NULL; }
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(HandleTraits);
@@ -131,10 +123,14 @@
public:
typedef HANDLE Handle;
- static void StartTracking(HANDLE handle, const void* owner,
- const void* pc1, const void* pc2) {}
- static void StopTracking(HANDLE handle, const void* owner,
- const void* pc1, const void* pc2) {}
+ static void StartTracking(HANDLE handle,
+ const void* owner,
+ const void* pc1,
+ const void* pc2) {}
+ static void StopTracking(HANDLE handle,
+ const void* owner,
+ const void* pc1,
+ const void* pc2) {}
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(DummyVerifierTraits);
@@ -145,10 +141,14 @@
public:
typedef HANDLE Handle;
- static void StartTracking(HANDLE handle, const void* owner,
- const void* pc1, const void* pc2);
- static void StopTracking(HANDLE handle, const void* owner,
- const void* pc1, const void* pc2);
+ static void StartTracking(HANDLE handle,
+ const void* owner,
+ const void* pc1,
+ const void* pc2);
+ static void StopTracking(HANDLE handle,
+ const void* owner,
+ const void* pc1,
+ const void* pc2);
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(VerifierTraits);
diff --git a/base/win/scoped_handle_test_dll.cc b/base/win/scoped_handle_test_dll.cc
index e17d6fd..9603d68 100644
--- a/base/win/scoped_handle_test_dll.cc
+++ b/base/win/scoped_handle_test_dll.cc
@@ -52,7 +52,7 @@
if (!ready_event)
return false;
- ThreadParams thread_params = { ready_event, start_event };
+ ThreadParams thread_params = {ready_event, start_event};
for (size_t i = 0; i < kNumThreads; i++) {
HANDLE thread_handle =
@@ -115,6 +115,6 @@
return InternalRunThreadTest() && InternalRunLocationTest();
}
-} // testing
-} // win
-} // base
+} // namespace testing
+} // namespace win
+} // namespace base
diff --git a/base/win/scoped_hdc.h b/base/win/scoped_hdc.h
index ef50e05..226b0b9 100644
--- a/base/win/scoped_hdc.h
+++ b/base/win/scoped_hdc.h
@@ -18,9 +18,7 @@
// GetDC.
class ScopedGetDC {
public:
- explicit ScopedGetDC(HWND hwnd)
- : hwnd_(hwnd),
- hdc_(GetDC(hwnd)) {
+ explicit ScopedGetDC(HWND hwnd) : hwnd_(hwnd), hdc_(GetDC(hwnd)) {
if (hwnd_) {
DCHECK(IsWindow(hwnd_));
DCHECK(hdc_);
@@ -53,17 +51,11 @@
public:
typedef HDC Handle;
- static bool CloseHandle(HDC handle) {
- return ::DeleteDC(handle) != FALSE;
- }
+ static bool CloseHandle(HDC handle) { return ::DeleteDC(handle) != FALSE; }
- static bool IsHandleValid(HDC handle) {
- return handle != NULL;
- }
+ static bool IsHandleValid(HDC handle) { return handle != NULL; }
- static HDC NullHandle() {
- return NULL;
- }
+ static HDC NullHandle() { return NULL; }
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(CreateDCTraits);
diff --git a/base/win/scoped_hglobal.h b/base/win/scoped_hglobal.h
index abe9a5a..2fa8aaa 100644
--- a/base/win/scoped_hglobal.h
+++ b/base/win/scoped_hglobal.h
@@ -5,8 +5,8 @@
#ifndef BASE_WIN_SCOPED_HGLOBAL_H_
#define BASE_WIN_SCOPED_HGLOBAL_H_
-#include <windows.h>
#include <stddef.h>
+#include <windows.h>
#include "base/macros.h"
@@ -14,15 +14,13 @@
namespace win {
// Like ScopedHandle except for HGLOBAL.
-template<class T>
+template <class T>
class ScopedHGlobal {
public:
explicit ScopedHGlobal(HGLOBAL glob) : glob_(glob) {
data_ = static_cast<T>(GlobalLock(glob_));
}
- ~ScopedHGlobal() {
- GlobalUnlock(glob_);
- }
+ ~ScopedHGlobal() { GlobalUnlock(glob_); }
T get() { return data_; }
diff --git a/base/win/scoped_process_information.cc b/base/win/scoped_process_information.cc
index 935a4cc..93fb9e6 100644
--- a/base/win/scoped_process_information.cc
+++ b/base/win/scoped_process_information.cc
@@ -20,9 +20,8 @@
return true;
HANDLE temp = NULL;
- if (!::DuplicateHandle(::GetCurrentProcess(), source,
- ::GetCurrentProcess(), &temp, 0, FALSE,
- DUPLICATE_SAME_ACCESS)) {
+ if (!::DuplicateHandle(::GetCurrentProcess(), source, ::GetCurrentProcess(),
+ &temp, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
DWORD last_error = ::GetLastError();
DPLOG(ERROR) << "Failed to duplicate a handle " << last_error;
::SetLastError(last_error);
@@ -35,11 +34,11 @@
} // namespace
ScopedProcessInformation::ScopedProcessInformation()
- : process_id_(0), thread_id_(0) {
-}
+ : process_id_(0), thread_id_(0) {}
ScopedProcessInformation::ScopedProcessInformation(
- const PROCESS_INFORMATION& process_info) : process_id_(0), thread_id_(0) {
+ const PROCESS_INFORMATION& process_info)
+ : process_id_(0), thread_id_(0) {
Set(process_info);
}
@@ -48,8 +47,8 @@
}
bool ScopedProcessInformation::IsValid() const {
- return process_id_ || process_handle_.Get() ||
- thread_id_ || thread_handle_.Get();
+ return process_id_ || process_handle_.Get() || thread_id_ ||
+ thread_handle_.Get();
}
void ScopedProcessInformation::Close() {
diff --git a/base/win/scoped_process_information.h b/base/win/scoped_process_information.h
index ca76e21..557555d 100644
--- a/base/win/scoped_process_information.h
+++ b/base/win/scoped_process_information.h
@@ -48,24 +48,16 @@
HANDLE TakeThreadHandle();
// Returns the held process handle, if any, while retaining ownership.
- HANDLE process_handle() const {
- return process_handle_.Get();
- }
+ HANDLE process_handle() const { return process_handle_.Get(); }
// Returns the held thread handle, if any, while retaining ownership.
- HANDLE thread_handle() const {
- return thread_handle_.Get();
- }
+ HANDLE thread_handle() const { return thread_handle_.Get(); }
// Returns the held process id, if any.
- DWORD process_id() const {
- return process_id_;
- }
+ DWORD process_id() const { return process_id_; }
// Returns the held thread id, if any.
- DWORD thread_id() const {
- return thread_id_;
- }
+ DWORD thread_id() const { return thread_id_; }
private:
ScopedHandle process_handle_;
diff --git a/base/win/scoped_propvariant.h b/base/win/scoped_propvariant.h
index aa9afec..0f1d5c8 100644
--- a/base/win/scoped_propvariant.h
+++ b/base/win/scoped_propvariant.h
@@ -17,13 +17,9 @@
// construction and destruction of this class.
class ScopedPropVariant {
public:
- ScopedPropVariant() {
- PropVariantInit(&pv_);
- }
+ ScopedPropVariant() { PropVariantInit(&pv_); }
- ~ScopedPropVariant() {
- Reset();
- }
+ ~ScopedPropVariant() { Reset(); }
// Returns a pointer to the underlying PROPVARIANT for use as an out param in
// a function call.
diff --git a/base/win/scoped_select_object.h b/base/win/scoped_select_object.h
index 59b21c1..d4b1a81 100644
--- a/base/win/scoped_select_object.h
+++ b/base/win/scoped_select_object.h
@@ -17,8 +17,7 @@
class ScopedSelectObject {
public:
ScopedSelectObject(HDC hdc, HGDIOBJ object)
- : hdc_(hdc),
- oldobj_(SelectObject(hdc, object)) {
+ : hdc_(hdc), oldobj_(SelectObject(hdc, object)) {
DCHECK(hdc_);
DCHECK(object);
DCHECK(oldobj_ != NULL && oldobj_ != HGDI_ERROR);
diff --git a/base/win/scoped_variant.cc b/base/win/scoped_variant.cc
deleted file mode 100644
index 0c1ee31..0000000
--- a/base/win/scoped_variant.cc
+++ /dev/null
@@ -1,277 +0,0 @@
-// Copyright (c) 2010 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/win/scoped_variant.h"
-
-#include "base/logging.h"
-
-namespace base {
-namespace win {
-
-// Global, const instance of an empty variant.
-const VARIANT ScopedVariant::kEmptyVariant = {{{VT_EMPTY}}};
-
-ScopedVariant::~ScopedVariant() {
- static_assert(sizeof(ScopedVariant) == sizeof(VARIANT), "ScopedVariantSize");
- ::VariantClear(&var_);
-}
-
-ScopedVariant::ScopedVariant(const wchar_t* str) {
- var_.vt = VT_EMPTY;
- Set(str);
-}
-
-ScopedVariant::ScopedVariant(const wchar_t* str, UINT length) {
- var_.vt = VT_BSTR;
- var_.bstrVal = ::SysAllocStringLen(str, length);
-}
-
-ScopedVariant::ScopedVariant(int value, VARTYPE vt) {
- var_.vt = vt;
- var_.lVal = value;
-}
-
-ScopedVariant::ScopedVariant(double value, VARTYPE vt) {
- DCHECK(vt == VT_R8 || vt == VT_DATE);
- var_.vt = vt;
- var_.dblVal = value;
-}
-
-ScopedVariant::ScopedVariant(IDispatch* dispatch) {
- var_.vt = VT_EMPTY;
- Set(dispatch);
-}
-
-ScopedVariant::ScopedVariant(IUnknown* unknown) {
- var_.vt = VT_EMPTY;
- Set(unknown);
-}
-
-ScopedVariant::ScopedVariant(SAFEARRAY* safearray) {
- var_.vt = VT_EMPTY;
- Set(safearray);
-}
-
-ScopedVariant::ScopedVariant(const VARIANT& var) {
- var_.vt = VT_EMPTY;
- Set(var);
-}
-
-void ScopedVariant::Reset(const VARIANT& var) {
- if (&var != &var_) {
- ::VariantClear(&var_);
- var_ = var;
- }
-}
-
-VARIANT ScopedVariant::Release() {
- VARIANT var = var_;
- var_.vt = VT_EMPTY;
- return var;
-}
-
-void ScopedVariant::Swap(ScopedVariant& var) {
- VARIANT tmp = var_;
- var_ = var.var_;
- var.var_ = tmp;
-}
-
-VARIANT* ScopedVariant::Receive() {
- DCHECK(!IsLeakableVarType(var_.vt)) << "variant leak. type: " << var_.vt;
- return &var_;
-}
-
-VARIANT ScopedVariant::Copy() const {
- VARIANT ret = {{{VT_EMPTY}}};
- ::VariantCopy(&ret, &var_);
- return ret;
-}
-
-int ScopedVariant::Compare(const VARIANT& var, bool ignore_case) const {
- ULONG flags = ignore_case ? NORM_IGNORECASE : 0;
- HRESULT hr = ::VarCmp(const_cast<VARIANT*>(&var_), const_cast<VARIANT*>(&var),
- LOCALE_USER_DEFAULT, flags);
- int ret = 0;
-
- switch (hr) {
- case VARCMP_LT:
- ret = -1;
- break;
-
- case VARCMP_GT:
- case VARCMP_NULL:
- ret = 1;
- break;
-
- default:
- // Equal.
- break;
- }
-
- return ret;
-}
-
-void ScopedVariant::Set(const wchar_t* str) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_BSTR;
- var_.bstrVal = ::SysAllocString(str);
-}
-
-void ScopedVariant::Set(int8_t i8) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_I1;
- var_.cVal = i8;
-}
-
-void ScopedVariant::Set(uint8_t ui8) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_UI1;
- var_.bVal = ui8;
-}
-
-void ScopedVariant::Set(int16_t i16) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_I2;
- var_.iVal = i16;
-}
-
-void ScopedVariant::Set(uint16_t ui16) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_UI2;
- var_.uiVal = ui16;
-}
-
-void ScopedVariant::Set(int32_t i32) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_I4;
- var_.lVal = i32;
-}
-
-void ScopedVariant::Set(uint32_t ui32) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_UI4;
- var_.ulVal = ui32;
-}
-
-void ScopedVariant::Set(int64_t i64) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_I8;
- var_.llVal = i64;
-}
-
-void ScopedVariant::Set(uint64_t ui64) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_UI8;
- var_.ullVal = ui64;
-}
-
-void ScopedVariant::Set(float r32) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_R4;
- var_.fltVal = r32;
-}
-
-void ScopedVariant::Set(double r64) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_R8;
- var_.dblVal = r64;
-}
-
-void ScopedVariant::SetDate(DATE date) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_DATE;
- var_.date = date;
-}
-
-void ScopedVariant::Set(IDispatch* disp) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_DISPATCH;
- var_.pdispVal = disp;
- if (disp)
- disp->AddRef();
-}
-
-void ScopedVariant::Set(bool b) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_BOOL;
- var_.boolVal = b ? VARIANT_TRUE : VARIANT_FALSE;
-}
-
-void ScopedVariant::Set(IUnknown* unk) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- var_.vt = VT_UNKNOWN;
- var_.punkVal = unk;
- if (unk)
- unk->AddRef();
-}
-
-void ScopedVariant::Set(SAFEARRAY* array) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- if (SUCCEEDED(::SafeArrayGetVartype(array, &var_.vt))) {
- var_.vt |= VT_ARRAY;
- var_.parray = array;
- } else {
- DCHECK(!array) << "Unable to determine safearray vartype";
- var_.vt = VT_EMPTY;
- }
-}
-
-void ScopedVariant::Set(const VARIANT& var) {
- DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
- if (FAILED(::VariantCopy(&var_, &var))) {
- DLOG(ERROR) << "VariantCopy failed";
- var_.vt = VT_EMPTY;
- }
-}
-
-ScopedVariant& ScopedVariant::operator=(const VARIANT& var) {
- if (&var != &var_) {
- VariantClear(&var_);
- Set(var);
- }
- return *this;
-}
-
-bool ScopedVariant::IsLeakableVarType(VARTYPE vt) {
- bool leakable = false;
- switch (vt & VT_TYPEMASK) {
- case VT_BSTR:
- case VT_DISPATCH:
- // we treat VT_VARIANT as leakable to err on the safe side.
- case VT_VARIANT:
- case VT_UNKNOWN:
- case VT_SAFEARRAY:
-
- // very rarely used stuff (if ever):
- case VT_VOID:
- case VT_PTR:
- case VT_CARRAY:
- case VT_USERDEFINED:
- case VT_LPSTR:
- case VT_LPWSTR:
- case VT_RECORD:
- case VT_INT_PTR:
- case VT_UINT_PTR:
- case VT_FILETIME:
- case VT_BLOB:
- case VT_STREAM:
- case VT_STORAGE:
- case VT_STREAMED_OBJECT:
- case VT_STORED_OBJECT:
- case VT_BLOB_OBJECT:
- case VT_VERSIONED_STREAM:
- case VT_BSTR_BLOB:
- leakable = true;
- break;
- }
-
- if (!leakable && (vt & VT_ARRAY) != 0) {
- leakable = true;
- }
-
- return leakable;
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/scoped_variant.h b/base/win/scoped_variant.h
deleted file mode 100644
index 5390eb9..0000000
--- a/base/win/scoped_variant.h
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright (c) 2011 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_SCOPED_VARIANT_H_
-#define BASE_WIN_SCOPED_VARIANT_H_
-
-#include <windows.h>
-#include <oleauto.h>
-#include <stdint.h>
-
-#include "base/macros.h"
-
-namespace base {
-namespace win {
-
-// Scoped VARIANT class for automatically freeing a COM VARIANT at the
-// end of a scope. Additionally provides a few functions to make the
-// encapsulated VARIANT easier to use.
-// Instead of inheriting from VARIANT, we take the containment approach
-// in order to have more control over the usage of the variant and guard
-// against memory leaks.
-class ScopedVariant {
- public:
- // Declaration of a global variant variable that's always VT_EMPTY
- static const VARIANT kEmptyVariant;
-
- // Default constructor.
- ScopedVariant() {
- // This is equivalent to what VariantInit does, but less code.
- var_.vt = VT_EMPTY;
- }
-
- // Constructor to create a new VT_BSTR VARIANT.
- // NOTE: Do not pass a BSTR to this constructor expecting ownership to
- // be transferred
- explicit ScopedVariant(const wchar_t* str);
-
- // Creates a new VT_BSTR variant of a specified length.
- ScopedVariant(const wchar_t* str, UINT length);
-
- // Creates a new integral type variant and assigns the value to
- // VARIANT.lVal (32 bit sized field).
- explicit ScopedVariant(int value, VARTYPE vt = VT_I4);
-
- // Creates a new double-precision type variant. |vt| must be either VT_R8
- // or VT_DATE.
- explicit ScopedVariant(double value, VARTYPE vt = VT_R8);
-
- // VT_DISPATCH
- explicit ScopedVariant(IDispatch* dispatch);
-
- // VT_UNKNOWN
- explicit ScopedVariant(IUnknown* unknown);
-
- // SAFEARRAY
- explicit ScopedVariant(SAFEARRAY* safearray);
-
- // Copies the variant.
- explicit ScopedVariant(const VARIANT& var);
-
- ~ScopedVariant();
-
- inline VARTYPE type() const {
- return var_.vt;
- }
-
- // Give ScopedVariant ownership over an already allocated VARIANT.
- void Reset(const VARIANT& var = kEmptyVariant);
-
- // Releases ownership of the VARIANT to the caller.
- VARIANT Release();
-
- // Swap two ScopedVariant's.
- void Swap(ScopedVariant& var);
-
- // Returns a copy of the variant.
- VARIANT Copy() const;
-
- // The return value is 0 if the variants are equal, 1 if this object is
- // greater than |var|, -1 if it is smaller.
- int Compare(const VARIANT& var, bool ignore_case = false) const;
-
- // Retrieves the pointer address.
- // Used to receive a VARIANT as an out argument (and take ownership).
- // The function DCHECKs on the current value being empty/null.
- // Usage: GetVariant(var.receive());
- VARIANT* Receive();
-
- void Set(const wchar_t* str);
-
- // Setters for simple types.
- void Set(int8_t i8);
- void Set(uint8_t ui8);
- void Set(int16_t i16);
- void Set(uint16_t ui16);
- void Set(int32_t i32);
- void Set(uint32_t ui32);
- void Set(int64_t i64);
- void Set(uint64_t ui64);
- void Set(float r32);
- void Set(double r64);
- void Set(bool b);
-
- // Creates a copy of |var| and assigns as this instance's value.
- // Note that this is different from the Reset() method that's used to
- // free the current value and assume ownership.
- void Set(const VARIANT& var);
-
- // COM object setters
- void Set(IDispatch* disp);
- void Set(IUnknown* unk);
-
- // SAFEARRAY support
- void Set(SAFEARRAY* array);
-
- // Special setter for DATE since DATE is a double and we already have
- // a setter for double.
- void SetDate(DATE date);
-
- // Allows const access to the contained variant without DCHECKs etc.
- // This support is necessary for the V_XYZ (e.g. V_BSTR) set of macros to
- // work properly but still doesn't allow modifications since we want control
- // over that.
- const VARIANT* ptr() const { return &var_; }
-
- // Like other scoped classes (e.g. scoped_refptr, ScopedBstr,
- // Microsoft::WRL::ComPtr) we support the assignment operator for the type we
- // wrap.
- ScopedVariant& operator=(const VARIANT& var);
-
- // A hack to pass a pointer to the variant where the accepting
- // function treats the variant as an input-only, read-only value
- // but the function prototype requires a non const variant pointer.
- // There's no DCHECK or anything here. Callers must know what they're doing.
- VARIANT* AsInput() const {
- // The nature of this function is const, so we declare
- // it as such and cast away the constness here.
- return const_cast<VARIANT*>(&var_);
- }
-
- // Allows the ScopedVariant instance to be passed to functions either by value
- // or by const reference.
- operator const VARIANT&() const {
- return var_;
- }
-
- // Used as a debug check to see if we're leaking anything.
- static bool IsLeakableVarType(VARTYPE vt);
-
- protected:
- VARIANT var_;
-
- private:
- // Comparison operators for ScopedVariant are not supported at this point.
- // Use the Compare method instead.
- bool operator==(const ScopedVariant& var) const;
- bool operator!=(const ScopedVariant& var) const;
- DISALLOW_COPY_AND_ASSIGN(ScopedVariant);
-};
-
-} // namespace win
-} // namespace base
-
-#endif // BASE_WIN_SCOPED_VARIANT_H_
diff --git a/base/win/shortcut.cc b/base/win/shortcut.cc
index 8abd5a6..fcd8a70 100644
--- a/base/win/shortcut.cc
+++ b/base/win/shortcut.cc
@@ -5,9 +5,9 @@
#include "base/win/shortcut.h"
#include <objbase.h>
+#include <propkey.h>
#include <shellapi.h>
#include <shlobj.h>
-#include <propkey.h>
#include <wrl/client.h>
#include "base/files/file_util.h"
@@ -44,14 +44,12 @@
} // namespace
ShortcutProperties::ShortcutProperties()
- : icon_index(-1), dual_mode(false), options(0U) {
-}
+ : icon_index(-1), dual_mode(false), options(0U) {}
ShortcutProperties::ShortcutProperties(const ShortcutProperties& other) =
default;
-ShortcutProperties::~ShortcutProperties() {
-}
+ShortcutProperties::~ShortcutProperties() {}
bool CreateOrUpdateShortcutLink(const FilePath& shortcut_path,
const ShortcutProperties& properties,
@@ -114,8 +112,8 @@
return false;
} else if (old_i_persist_file.Get()) {
wchar_t current_arguments[MAX_PATH] = {0};
- if (SUCCEEDED(old_i_shell_link->GetArguments(current_arguments,
- MAX_PATH))) {
+ if (SUCCEEDED(
+ old_i_shell_link->GetArguments(current_arguments, MAX_PATH))) {
i_shell_link->SetArguments(current_arguments);
}
}
@@ -144,15 +142,13 @@
!property_store.Get())
return false;
- if (has_app_id &&
- !SetAppIdForPropertyStore(property_store.Get(),
- properties.app_id.c_str())) {
+ if (has_app_id && !SetAppIdForPropertyStore(property_store.Get(),
+ properties.app_id.c_str())) {
return false;
}
- if (has_dual_mode &&
- !SetBooleanValueForPropertyStore(property_store.Get(),
- PKEY_AppUserModel_IsDualMode,
- properties.dual_mode)) {
+ if (has_dual_mode && !SetBooleanValueForPropertyStore(
+ property_store.Get(), PKEY_AppUserModel_IsDualMode,
+ properties.dual_mode)) {
return false;
}
if (has_toast_activator_clsid &&
@@ -262,8 +258,8 @@
if (options & ShortcutProperties::PROPERTIES_APP_ID) {
ScopedPropVariant pv_app_id;
- if (property_store->GetValue(PKEY_AppUserModel_ID,
- pv_app_id.Receive()) != S_OK) {
+ if (property_store->GetValue(PKEY_AppUserModel_ID, pv_app_id.Receive()) !=
+ S_OK) {
return false;
}
switch (pv_app_id.get().vt) {
diff --git a/base/win/shortcut.h b/base/win/shortcut.h
index 1ab0188..d5bcff7 100644
--- a/base/win/shortcut.h
+++ b/base/win/shortcut.h
@@ -5,8 +5,8 @@
#ifndef BASE_WIN_SHORTCUT_H_
#define BASE_WIN_SHORTCUT_H_
-#include <windows.h>
#include <stdint.h>
+#include <windows.h>
#include "base/files/file_path.h"
#include "base/logging.h"
@@ -130,10 +130,9 @@
// |operation|: a choice from the ShortcutOperation enum.
// If |operation| is SHORTCUT_REPLACE_EXISTING or SHORTCUT_UPDATE_EXISTING and
// |shortcut_path| does not exist, this method is a no-op and returns false.
-bool CreateOrUpdateShortcutLink(
- const FilePath& shortcut_path,
- const ShortcutProperties& properties,
- ShortcutOperation operation);
+bool CreateOrUpdateShortcutLink(const FilePath& shortcut_path,
+ const ShortcutProperties& properties,
+ ShortcutOperation operation);
// Resolves Windows shortcut (.LNK file).
// This methods tries to resolve selected properties of a shortcut .LNK file.
@@ -146,8 +145,8 @@
// properties are successfully read. Otherwise some reads have failed and
// intermediate values written to |properties| should be ignored.
bool ResolveShortcutProperties(const FilePath& shortcut_path,
- uint32_t options,
- ShortcutProperties* properties);
+ uint32_t options,
+ ShortcutProperties* properties);
// Resolves Windows shortcut (.LNK file).
// This is a wrapper to ResolveShortcutProperties() to handle the common use
@@ -157,8 +156,8 @@
// successfully. Callers can safely use the same variable for both
// |shortcut_path| and |target_path|.
bool ResolveShortcut(const FilePath& shortcut_path,
- FilePath* target_path,
- string16* args);
+ FilePath* target_path,
+ string16* args);
// Pin to taskbar is only supported on Windows 7 and Windows 8. Returns true on
// those platforms.
diff --git a/base/win/startup_information.cc b/base/win/startup_information.cc
index 9986674..fbfb093 100644
--- a/base/win/startup_information.cc
+++ b/base/win/startup_information.cc
@@ -8,7 +8,7 @@
namespace {
-typedef BOOL (WINAPI *InitializeProcThreadAttributeListFunction)(
+typedef BOOL(WINAPI* InitializeProcThreadAttributeListFunction)(
LPPROC_THREAD_ATTRIBUTE_LIST attribute_list,
DWORD attribute_count,
DWORD flags,
@@ -16,7 +16,7 @@
static InitializeProcThreadAttributeListFunction
initialize_proc_thread_attribute_list;
-typedef BOOL (WINAPI *UpdateProcThreadAttributeFunction)(
+typedef BOOL(WINAPI* UpdateProcThreadAttributeFunction)(
LPPROC_THREAD_ATTRIBUTE_LIST attribute_list,
DWORD flags,
DWORD_PTR attribute,
@@ -26,7 +26,7 @@
PSIZE_T return_size);
static UpdateProcThreadAttributeFunction update_proc_thread_attribute_list;
-typedef VOID (WINAPI *DeleteProcThreadAttributeListFunction)(
+typedef VOID(WINAPI* DeleteProcThreadAttributeListFunction)(
LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList);
static DeleteProcThreadAttributeListFunction delete_proc_thread_attribute_list;
@@ -59,7 +59,7 @@
StartupInformation::~StartupInformation() {
if (startup_info_.lpAttributeList) {
delete_proc_thread_attribute_list(startup_info_.lpAttributeList);
- delete [] reinterpret_cast<BYTE*>(startup_info_.lpAttributeList);
+ delete[] reinterpret_cast<BYTE*>(startup_info_.lpAttributeList);
}
}
@@ -77,8 +77,8 @@
startup_info_.lpAttributeList =
reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(new BYTE[size]);
if (!initialize_proc_thread_attribute_list(startup_info_.lpAttributeList,
- attribute_count, 0, &size)) {
- delete [] reinterpret_cast<BYTE*>(startup_info_.lpAttributeList);
+ attribute_count, 0, &size)) {
+ delete[] reinterpret_cast<BYTE*>(startup_info_.lpAttributeList);
startup_info_.lpAttributeList = NULL;
return false;
}
@@ -86,16 +86,14 @@
return true;
}
-bool StartupInformation::UpdateProcThreadAttribute(
- DWORD_PTR attribute,
- void* value,
- size_t size) {
+bool StartupInformation::UpdateProcThreadAttribute(DWORD_PTR attribute,
+ void* value,
+ size_t size) {
if (!startup_info_.lpAttributeList)
return false;
- return !!update_proc_thread_attribute_list(startup_info_.lpAttributeList, 0,
- attribute, value, size, NULL, NULL);
+ return !!update_proc_thread_attribute_list(
+ startup_info_.lpAttributeList, 0, attribute, value, size, NULL, NULL);
}
} // namespace win
} // namespace base
-
diff --git a/base/win/startup_information.h b/base/win/startup_information.h
index f82ff75..d95f39b 100644
--- a/base/win/startup_information.h
+++ b/base/win/startup_information.h
@@ -5,8 +5,8 @@
#ifndef BASE_WIN_STARTUP_INFORMATION_H_
#define BASE_WIN_STARTUP_INFORMATION_H_
-#include <windows.h>
#include <stddef.h>
+#include <windows.h>
#include "base/macros.h"
@@ -26,9 +26,7 @@
// Sets one entry in the initialized attribute list.
// |value| needs to live at least as long as the StartupInformation object
// this is called on.
- bool UpdateProcThreadAttribute(DWORD_PTR attribute,
- void* value,
- size_t size);
+ bool UpdateProcThreadAttribute(DWORD_PTR attribute, void* value, size_t size);
LPSTARTUPINFOW startup_info() { return &startup_info_.StartupInfo; }
LPSTARTUPINFOW startup_info() const {
diff --git a/base/win/wait_chain.cc b/base/win/wait_chain.cc
deleted file mode 100644
index a18a1ea..0000000
--- a/base/win/wait_chain.cc
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright 2016 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/win/wait_chain.h"
-
-#include <memory>
-
-#include "base/logging.h"
-#include "base/strings/stringprintf.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-// Helper deleter to hold a HWCT into a unique_ptr.
-struct WaitChainSessionDeleter {
- using pointer = HWCT;
- void operator()(HWCT session_handle) const {
- ::CloseThreadWaitChainSession(session_handle);
- }
-};
-
-using ScopedWaitChainSessionHandle =
- std::unique_ptr<HWCT, WaitChainSessionDeleter>;
-
-const wchar_t* WctObjectTypeToString(WCT_OBJECT_TYPE type) {
- switch (type) {
- case WctCriticalSectionType:
- return L"CriticalSection";
- case WctSendMessageType:
- return L"SendMessage";
- case WctMutexType:
- return L"Mutex";
- case WctAlpcType:
- return L"Alpc";
- case WctComType:
- return L"Com";
- case WctThreadWaitType:
- return L"ThreadWait";
- case WctProcessWaitType:
- return L"ProcessWait";
- case WctThreadType:
- return L"Thread";
- case WctComActivationType:
- return L"ComActivation";
- case WctUnknownType:
- return L"Unknown";
- case WctSocketIoType:
- return L"SocketIo";
- case WctSmbIoType:
- return L"SmbIo";
- case WctMaxType:
- break;
- }
- NOTREACHED();
- return L"";
-}
-
-const wchar_t* WctObjectStatusToString(WCT_OBJECT_STATUS status) {
- switch (status) {
- case WctStatusNoAccess:
- return L"NoAccess";
- case WctStatusRunning:
- return L"Running";
- case WctStatusBlocked:
- return L"Blocked";
- case WctStatusPidOnly:
- return L"PidOnly";
- case WctStatusPidOnlyRpcss:
- return L"PidOnlyRpcss";
- case WctStatusOwned:
- return L"Owned";
- case WctStatusNotOwned:
- return L"NotOwned";
- case WctStatusAbandoned:
- return L"Abandoned";
- case WctStatusUnknown:
- return L"Unknown";
- case WctStatusError:
- return L"Error";
- case WctStatusMax:
- break;
- }
- NOTREACHED();
- return L"";
-}
-
-} // namespace
-
-bool GetThreadWaitChain(DWORD thread_id,
- WaitChainNodeVector* wait_chain,
- bool* is_deadlock,
- base::string16* failure_reason,
- DWORD* last_error) {
- DCHECK(wait_chain);
- DCHECK(is_deadlock);
-
- constexpr wchar_t kWaitChainSessionFailureReason[] =
- L"OpenThreadWaitChainSession() failed.";
- constexpr wchar_t kGetWaitChainFailureReason[] =
- L"GetThreadWaitChain() failed.";
-
- // Open a synchronous session.
- ScopedWaitChainSessionHandle session_handle(
- ::OpenThreadWaitChainSession(0, nullptr));
- if (!session_handle) {
- if (last_error)
- *last_error = ::GetLastError();
- if (failure_reason)
- *failure_reason = kWaitChainSessionFailureReason;
- DPLOG(ERROR) << kWaitChainSessionFailureReason;
- return false;
- }
-
- DWORD nb_nodes = WCT_MAX_NODE_COUNT;
- wait_chain->resize(nb_nodes);
- BOOL is_cycle;
- if (!::GetThreadWaitChain(session_handle.get(), NULL, 0, thread_id, &nb_nodes,
- wait_chain->data(), &is_cycle)) {
- if (last_error)
- *last_error = ::GetLastError();
- if (failure_reason)
- *failure_reason = kGetWaitChainFailureReason;
- DPLOG(ERROR) << kGetWaitChainFailureReason;
- return false;
- }
-
- *is_deadlock = is_cycle ? true : false;
- wait_chain->resize(nb_nodes);
-
- return true;
-}
-
-base::string16 WaitChainNodeToString(const WAITCHAIN_NODE_INFO& node) {
- if (node.ObjectType == WctThreadType) {
- return base::StringPrintf(L"Thread %d in process %d with status %ls",
- node.ThreadObject.ThreadId,
- node.ThreadObject.ProcessId,
- WctObjectStatusToString(node.ObjectStatus));
- } else {
- return base::StringPrintf(L"Lock of type %ls with status %ls",
- WctObjectTypeToString(node.ObjectType),
- WctObjectStatusToString(node.ObjectStatus));
- }
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/wait_chain.h b/base/win/wait_chain.h
deleted file mode 100644
index 0b5947b..0000000
--- a/base/win/wait_chain.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2016 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_WAIT_CHAIN_H_
-#define BASE_WIN_WAIT_CHAIN_H_
-
-#include <windows.h>
-#include <wct.h>
-
-#include <vector>
-
-#include "base/strings/string16.h"
-
-namespace base {
-namespace win {
-
-using WaitChainNodeVector = std::vector<WAITCHAIN_NODE_INFO>;
-
-// Gets the wait chain for |thread_id|. Also specifies if the |wait_chain|
-// contains a deadlock. Returns true on success.
-//
-// From MSDN: A wait chain is an alternating sequence of threads and
-// synchronization objects; each thread waits for the object that follows it,
-// which is owned by the subsequent thread in the chain.
-//
-// On error, |failure_reason| and/or |last_error| will contain the details of
-// the failure, given that they are not null.
-// TODO(pmonette): Remove |failure_reason| and |last_error| when UMA is
-// supported in the watcher process and pre-rendez-vous.
-bool GetThreadWaitChain(DWORD thread_id,
- WaitChainNodeVector* wait_chain,
- bool* is_deadlock,
- base::string16* failure_reason,
- DWORD* last_error);
-
-// Returns a string that represents the node for a wait chain.
-base::string16 WaitChainNodeToString(
- const WAITCHAIN_NODE_INFO& node);
-
-} // namespace win
-} // namespace base
-
-#endif // BASE_WIN_WAIT_CHAIN_H_
diff --git a/base/win/win_util.cc b/base/win/win_util.cc
index b3867b4..d9efb6e 100644
--- a/base/win/win_util.cc
+++ b/base/win/win_util.cc
@@ -125,11 +125,9 @@
void GetNonClientMetrics(NONCLIENTMETRICS_XP* metrics) {
DCHECK(metrics);
metrics->cbSize = sizeof(*metrics);
- const bool success = !!SystemParametersInfo(
- SPI_GETNONCLIENTMETRICS,
- metrics->cbSize,
- reinterpret_cast<NONCLIENTMETRICS*>(metrics),
- 0);
+ const bool success =
+ !!SystemParametersInfo(SPI_GETNONCLIENTMETRICS, metrics->cbSize,
+ reinterpret_cast<NONCLIENTMETRICS*>(metrics), 0);
DCHECK(success);
}
@@ -183,8 +181,7 @@
return false;
}
- return SetPropVariantValueForPropertyStore(property_store,
- property_key,
+ return SetPropVariantValueForPropertyStore(property_store, property_key,
property_value);
}
@@ -197,8 +194,7 @@
return false;
}
- return SetPropVariantValueForPropertyStore(property_store,
- property_key,
+ return SetPropVariantValueForPropertyStore(property_store, property_key,
property_value);
}
@@ -222,19 +218,19 @@
// See http://msdn.microsoft.com/en-us/library/dd378459%28VS.85%29.aspx
DCHECK(lstrlen(app_id) < 64 && wcschr(app_id, L' ') == NULL);
- return SetStringValueForPropertyStore(property_store,
- PKEY_AppUserModel_ID,
+ return SetStringValueForPropertyStore(property_store, PKEY_AppUserModel_ID,
app_id);
}
static const char16 kAutoRunKeyPath[] =
L"Software\\Microsoft\\Windows\\CurrentVersion\\Run";
-bool AddCommandToAutoRun(HKEY root_key, const string16& name,
+bool AddCommandToAutoRun(HKEY root_key,
+ const string16& name,
const string16& command) {
RegKey autorun_key(root_key, kAutoRunKeyPath, KEY_SET_VALUE);
return (autorun_key.WriteValue(name.c_str(), command.c_str()) ==
- ERROR_SUCCESS);
+ ERROR_SUCCESS);
}
bool RemoveCommandFromAutoRun(HKEY root_key, const string16& name) {
@@ -348,8 +344,8 @@
void DisableFlicks(HWND hwnd) {
::SetProp(hwnd, MICROSOFT_TABLETPENSERVICE_PROPERTY,
- reinterpret_cast<HANDLE>(TABLET_DISABLE_FLICKS |
- TABLET_DISABLE_FLICKFALLBACKKEYS));
+ reinterpret_cast<HANDLE>(TABLET_DISABLE_FLICKS |
+ TABLET_DISABLE_FLICKFALLBACKKEYS));
}
bool IsProcessPerMonitorDpiAware() {
diff --git a/base/win/win_util.h b/base/win/win_util.h
index 1acd455..08738cb 100644
--- a/base/win/win_util.h
+++ b/base/win/win_util.h
@@ -62,32 +62,31 @@
bool UserAccountControlIsEnabled();
// Sets the boolean value for a given key in given IPropertyStore.
-bool SetBooleanValueForPropertyStore(
- IPropertyStore* property_store,
- const PROPERTYKEY& property_key,
- bool property_bool_value);
+bool SetBooleanValueForPropertyStore(IPropertyStore* property_store,
+ const PROPERTYKEY& property_key,
+ bool property_bool_value);
// Sets the string value for a given key in given IPropertyStore.
-bool SetStringValueForPropertyStore(
- IPropertyStore* property_store,
- const PROPERTYKEY& property_key,
- const wchar_t* property_string_value);
+bool SetStringValueForPropertyStore(IPropertyStore* property_store,
+ const PROPERTYKEY& property_key,
+ const wchar_t* property_string_value);
// Sets the CLSID value for a given key in a given IPropertyStore.
bool SetClsidForPropertyStore(IPropertyStore* property_store,
- const PROPERTYKEY& property_key,
- const CLSID& property_clsid_value);
+ const PROPERTYKEY& property_key,
+ const CLSID& property_clsid_value);
// Sets the application id in given IPropertyStore. The function is intended
// for tagging application/chromium shortcut, browser window and jump list for
// Win7.
bool SetAppIdForPropertyStore(IPropertyStore* property_store,
- const wchar_t* app_id);
+ const wchar_t* app_id);
// Adds the specified |command| using the specified |name| to the AutoRun key.
// |root_key| could be HKCU or HKLM or the root of any user hive.
-bool AddCommandToAutoRun(HKEY root_key, const string16& name,
- const string16& command);
+bool AddCommandToAutoRun(HKEY root_key,
+ const string16& name,
+ const string16& command);
// Removes the command specified by |name| from the AutoRun key. |root_key|
// could be HKCU or HKLM or the root of any user hive.
bool RemoveCommandFromAutoRun(HKEY root_key, const string16& name);
@@ -95,8 +94,8 @@
// Reads the command specified by |name| from the AutoRun key. |root_key|
// could be HKCU or HKLM or the root of any user hive. Used for unit-tests.
bool ReadCommandFromAutoRun(HKEY root_key,
- const string16& name,
- string16* command);
+ const string16& name,
+ string16* command);
// Sets whether to crash the process during exit. This is inspected by DLLMain
// and used to intercept unexpected terminations of the process (via calls to
@@ -114,8 +113,8 @@
// This is necessary to set compatible struct sizes for different versions
// of certain Windows APIs (e.g. SystemParametersInfo).
#define SIZEOF_STRUCT_WITH_SPECIFIED_LAST_MEMBER(struct_name, member) \
- offsetof(struct_name, member) + \
- (sizeof static_cast<struct_name*>(NULL)->member)
+ offsetof(struct_name, member) + \
+ (sizeof static_cast<struct_name*>(NULL)->member)
// Used by tests to mock any wanted state. Call with |state| set to true to
// simulate being in a domain and false otherwise.
@@ -132,8 +131,7 @@
// HMODULEs are not add-ref'd, so they should not be closed and may be
// invalidated at any time (should a module be unloaded). |process| requires
// the PROCESS_QUERY_INFORMATION and PROCESS_VM_READ permissions.
-bool GetLoadedModulesSnapshot(HANDLE process,
- std::vector<HMODULE>* snapshot);
+bool GetLoadedModulesSnapshot(HANDLE process, std::vector<HMODULE>* snapshot);
// Adds or removes the MICROSOFT_TABLETPENSERVICE_PROPERTY property with the
// TABLET_DISABLE_FLICKS & TABLET_DISABLE_FLICKFALLBACKKEYS flags in order to
diff --git a/base/win/windows_types.h b/base/win/windows_types.h
index 2a86195..d076c44 100644
--- a/base/win/windows_types.h
+++ b/base/win/windows_types.h
@@ -68,7 +68,6 @@
typedef DWORD ACCESS_MASK;
typedef ACCESS_MASK REGSAM;
-
// Forward declare Windows compatible handles.
#define CHROME_DECLARE_HANDLE(name) \
@@ -84,7 +83,6 @@
typedef HINSTANCE HMODULE;
#undef CHROME_DECLARE_HANDLE
-
// Forward declare some Windows struct/typedef sets.
typedef struct _OVERLAPPED OVERLAPPED;
@@ -118,10 +116,11 @@
PVOID Ptr;
};
-
// Define some commonly used Windows constants. Note that the layout of these
// macros - including internal spacing - must be 100% consistent with windows.h.
+// clang-format off
+
#ifndef INVALID_HANDLE_VALUE
// Work around there being two slightly different definitions in the SDK.
#define INVALID_HANDLE_VALUE ((HANDLE)(LONG_PTR)-1)
@@ -196,6 +195,8 @@
#define WINAPI __stdcall
#define CALLBACK __stdcall
+// clang-format on
+
// Needed for optimal lock performance.
WINBASEAPI _Releases_exclusive_lock_(*SRWLock) VOID WINAPI
ReleaseSRWLockExclusive(_Inout_ PSRWLOCK SRWLock);
diff --git a/base/win/windows_version.cc b/base/win/windows_version.cc
index 6b7be76..dd45286 100644
--- a/base/win/windows_version.cc
+++ b/base/win/windows_version.cc
@@ -23,7 +23,7 @@
#endif
namespace {
-typedef BOOL (WINAPI *GetProductInfoPtr)(DWORD, DWORD, DWORD, DWORD, PDWORD);
+typedef BOOL(WINAPI* GetProductInfoPtr)(DWORD, DWORD, DWORD, DWORD, PDWORD);
} // namespace
namespace base {
@@ -104,8 +104,8 @@
static OSInfo* info;
if (!info) {
OSInfo* new_info = new OSInfo();
- if (InterlockedCompareExchangePointer(
- reinterpret_cast<PVOID*>(&info), new_info, NULL)) {
+ if (InterlockedCompareExchangePointer(reinterpret_cast<PVOID*>(&info),
+ new_info, NULL)) {
delete new_info;
}
}
@@ -117,7 +117,7 @@
kernel32_version_(VERSION_PRE_XP),
architecture_(OTHER_ARCHITECTURE),
wow64_status_(GetWOW64StatusForProcess(GetCurrentProcess())) {
- OSVERSIONINFOEX version_info = { sizeof version_info };
+ OSVERSIONINFOEX version_info = {sizeof version_info};
::GetVersionEx(reinterpret_cast<OSVERSIONINFO*>(&version_info));
version_number_.major = version_info.dwMajorVersion;
version_number_.minor = version_info.dwMinorVersion;
@@ -132,9 +132,15 @@
SYSTEM_INFO system_info = {};
::GetNativeSystemInfo(&system_info);
switch (system_info.wProcessorArchitecture) {
- case PROCESSOR_ARCHITECTURE_INTEL: architecture_ = X86_ARCHITECTURE; break;
- case PROCESSOR_ARCHITECTURE_AMD64: architecture_ = X64_ARCHITECTURE; break;
- case PROCESSOR_ARCHITECTURE_IA64: architecture_ = IA64_ARCHITECTURE; break;
+ case PROCESSOR_ARCHITECTURE_INTEL:
+ architecture_ = X86_ARCHITECTURE;
+ break;
+ case PROCESSOR_ARCHITECTURE_AMD64:
+ architecture_ = X64_ARCHITECTURE;
+ break;
+ case PROCESSOR_ARCHITECTURE_IA64:
+ architecture_ = IA64_ARCHITECTURE;
+ break;
}
processors_ = system_info.dwNumberOfProcessors;
allocation_granularity_ = system_info.dwAllocationGranularity;
@@ -213,8 +219,7 @@
}
}
-OSInfo::~OSInfo() {
-}
+OSInfo::~OSInfo() {}
std::string OSInfo::processor_model_name() {
if (processor_model_name_.empty()) {
@@ -230,7 +235,7 @@
// static
OSInfo::WOW64Status OSInfo::GetWOW64StatusForProcess(HANDLE process_handle) {
- typedef BOOL (WINAPI* IsWow64ProcessFunc)(HANDLE, PBOOL);
+ typedef BOOL(WINAPI * IsWow64ProcessFunc)(HANDLE, PBOOL);
IsWow64ProcessFunc is_wow64_process = reinterpret_cast<IsWow64ProcessFunc>(
GetProcAddress(GetModuleHandle(L"kernel32.dll"), "IsWow64Process"));
if (!is_wow64_process)
diff --git a/base/win/winrt_storage_util.h b/base/win/winrt_storage_util.h
index 5578415..8cf57d4 100644
--- a/base/win/winrt_storage_util.h
+++ b/base/win/winrt_storage_util.h
@@ -9,7 +9,6 @@
#include <windows.storage.streams.h>
#include <wrl/client.h>
-
namespace base {
namespace win {
