Implement fast path in UTF8ToUTF16 for pure ASCII strings

base/strings/string_util.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file defines utility functions for working with strings.
 
 #ifndef BASE_STRINGS_STRING_UTIL_H_
 #define BASE_STRINGS_STRING_UTIL_H_
 
 #include <ctype.h>
@@ skipping 227 matching lines @@
 // string be 8-bit or UTF8? It contains only characters that are < 256 (in the
 // first case) or characters that use only 8-bits and whose 8-bit
 // representation looks like a UTF-8 string (the second case).
 //
 // Note that IsStringUTF8 checks not only if the input is structurally
 // valid but also if it doesn't contain any non-character codepoint
 // (e.g. U+FFFE). It's done on purpose because all the existing callers want
 // to have the maximum 'discriminating' power from other encodings. If
 // there's a use case for just checking the structural validity, we have to
 // add a new function for that.
+//
+// IsStringASCII assumes the input is likely all ASCII, and does not leave early
+// if it is not the case.
 BASE_EXPORT bool IsStringUTF8(const std::string& str);
 BASE_EXPORT bool IsStringASCII(const StringPiece& str);
 BASE_EXPORT bool IsStringASCII(const string16& str);
+BASE_EXPORT bool IsStringASCII(const char* src, size_t src_len);

[brettw, 2014/09/16 17:14:28]

The string piece version should cover this case. Actually, I think we should
have a a StringPiece and a StringPiece16 version of this function and nothing
else. StringPiece is supposed to handle exactly what you're doing.

[mnaganov (inactive), 2014/09/17 15:15:01]

You are right, I didn't think about this, thanks!

Overloaded version taking StringPiece16 is useful for testing various input
alignments, so I added it. However, removing the string16 version will require
changing all the places where IsStringASCII is called on a WebString.

WebString provides conversions to string / string16, but not to a StringPiece,
which makes sense, because StringPiece doesn't own the data. I guess, this is
the reason why UTF16To... functions are also operating on string16, and not on
StringPiece16.

I added a comment justifying the existence of the string16 version.

+BASE_EXPORT bool IsStringASCII(const char16* src, size_t src_len);
 
 // 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 StringToLowerASCII(str* s) {
   for (typename str::iterator i = s->begin(); i != s->end(); ++i)
     *i = ToLowerASCII(*i);
 }
 
 template <class str> inline str StringToLowerASCII(const str& s) {
   // for std::string and std::wstring
@@ skipping 253 matching lines @@
 #elif defined(WCHAR_T_IS_UTF32)
   typedef uint32 Unsigned;
 #endif
 };
 template<>
 struct ToUnsigned<short> {
   typedef unsigned short Unsigned;
 };
 
 #endif  // BASE_STRINGS_STRING_UTIL_H_