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 {