Add ToUpperASCII and StringToUpperASCII.

base/string_util.h

 // Copyright (c) 2006-2008 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.
 //
 // This file defines utility functions for working with strings.
 
 #ifndef BASE_STRING_UTIL_H_
 #define BASE_STRING_UTIL_H_
 
+#include <stdarg.h>   // va_list
+
 #include <string>
 #include <vector>
-#include <stdarg.h>   // va_list
 
 #include "base/basictypes.h"
 #include "base/string16.h"
 
 // Safe standard library wrappers for all platforms.
 
 namespace base {
 
 // C standard-library functions like "strncasecmp" and "snprintf" that aren't
 // cross-platform are provided as "base::strncasecmp", and their prototypes
@@ skipping 144 matching lines @@
 // return strings ignore this error and just return the best conversion
 // possible.
 bool WideToUTF8(const wchar_t* src, size_t src_len, std::string* output);
 std::string WideToUTF8(const std::wstring& wide);
 bool UTF8ToWide(const char* src, size_t src_len, std::wstring* output);
 std::wstring UTF8ToWide(const std::string& utf8);
 
 bool WideToUTF16(const wchar_t* src, size_t src_len, string16* output);
 string16 WideToUTF16(const std::wstring& wide);
 bool UTF16ToWide(const char16* src, size_t src_len, std::wstring* output);
-std::wstring UTF16ToWide(const string16& utf8);
+std::wstring UTF16ToWide(const string16& utf16);
 
 bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);
 string16 UTF8ToUTF16(const std::string& utf8);
 bool UTF16ToUTF8(const char16* src, size_t src_len, std::string* output);
 std::string UTF16ToUTF8(const string16& utf16);
 
 // Defines the error handling modes of WideToCodepage and CodepageToWide.
 class OnStringUtilConversionError {
  public:
   enum Type {
@@ skipping 48 matching lines @@
     *i = ToLowerASCII(*i);
 }
 
 template <class str> inline str StringToLowerASCII(const str& s) {
   // for std::string and std::wstring
   str output(s);
   StringToLowerASCII(&output);
   return output;
 }
 
+// ASCII-specific toupper.  The standard library's toupper is locale sensitive,
+// so we don't want to use it here.
+template <class Char> inline Char ToUpperASCII(Char c) {
+  return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
+}
+
+// Converts the elements of the given string.  This version uses a pointer to
+// clearly differentiate it from the non-pointer variant.
+template <class str> inline void StringToUpperASCII(str* s) {
+  for (typename str::iterator i = s->begin(); i != s->end(); ++i)
+    *i = ToUpperASCII(*i);
+}
+
+template <class str> inline str StringToUpperASCII(const str& s) {
+  // for std::string and std::wstring
+  str output(s);
+  StringToUpperASCII(&output);
+  return output;
+}
+
 // Compare the lower-case form of the given string against the given ASCII
 // string.  This is useful for doing checking if an input string matches some
 // token, and it is optimized to avoid intermediate string copies.  This API is
 // borrowed from the equivalent APIs in Mozilla.
 bool LowerCaseEqualsASCII(const std::string& a, const char* b);
 bool LowerCaseEqualsASCII(const std::wstring& a, const char* b);
 
 // Same thing, but with string iterators instead.
 bool LowerCaseEqualsASCII(std::string::const_iterator a_begin,
                           std::string::const_iterator a_end,
@@ skipping 297 matching lines @@
 // Returns a hex string representation of a binary buffer.
 // The returned hex string will be in upper case.
 // This function does not check if |size| is within reasonable limits since
 // it's written with trusted data in mind.
 // If you suspect that the data you want to format might be large,
 // the absolute max size for |size| should be is
 //   std::numeric_limits<size_t>::max() / 2
 std::string HexEncode(const void* bytes, size_t size);
 
 #endif  // BASE_STRING_UTIL_H_