Make UTF8ToWide take a StringPiece, to avoid copying to a std::string.

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 "base/basictypes.h"
 #include "base/string16.h"
+#include "base/string_piece.h"  // For implicit conversions.
 
 // 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
 // are listed below.  These functions are then implemented as inline calls
 // to the platform-specific equivalents in the platform-specific headers.
 
@@ skipping 139 matching lines @@
 
 // These convert between UTF-8, -16, and -32 strings. They are potentially slow,
 // so avoid unnecessary conversions. The low-level versions return a boolean
 // indicating whether the conversion was 100% valid. In this case, it will still
 // do the best it can and put the result in the output buffer. The versions that
 // return strings ignore this error and just return the best conversion
 // possible.
 bool WideToUTF8(const wchar_t* src, size_t src_len, std::string* output);
 std::string WideToUTF8(const std::wstring& wide);
 bool UTF8ToWide(const char* src, size_t src_len, std::wstring* output);
-std::wstring UTF8ToWide(const std::string& utf8);
+std::wstring UTF8ToWide(const StringPiece& 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& utf16);
 
 bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);
 string16 UTF8ToUTF16(const std::string& utf8);

[darin (slow to review), 2009/03/04 16:33:23]

this looks like another good place to use this.

it'd be great too if we had a String16Piece :)

 bool UTF16ToUTF8(const char16* src, size_t src_len, std::string* output);
 std::string UTF16ToUTF8(const string16& utf16);
 
 // We are trying to get rid of wstring as much as possible, but it's too big
 // a mess to do it all at once.  These conversions should be used when we
 // really should just be passing a string16 around, but we haven't finished
 // porting whatever module uses wstring and the conversion is being used as a
 // stopcock.  This makes it easy to grep for the ones that should be removed.
 #if defined(OS_WIN)
 # define WideToUTF16Hack
@@ skipping 397 matching lines @@
 // 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_