1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/strings/sys_string_conversions.h"
6
7#import <Foundation/Foundation.h>
8#include <stddef.h>
9
10#include <vector>
11
12#include "base/mac/foundation_util.h"
13#include "base/mac/scoped_cftyperef.h"
14#include "base/strings/string_piece.h"
15
16namespace base {
17
18namespace {
19
20// Convert the supplied CFString into the specified encoding, and return it as
21// an STL string of the template type.  Returns an empty string on failure.
22//
23// Do not assert in this function since it is used by the asssertion code!
24template<typename StringType>
25static StringType CFStringToSTLStringWithEncodingT(CFStringRef cfstring,
26                                                   CFStringEncoding encoding) {
27  CFIndex length = CFStringGetLength(cfstring);
28  if (length == 0)
29    return StringType();
30
31  CFRange whole_string = CFRangeMake(0, length);
32  CFIndex out_size;
33  CFIndex converted = CFStringGetBytes(cfstring,
34                                       whole_string,
35                                       encoding,
36                                       0,      // lossByte
37                                       false,  // isExternalRepresentation
38                                       NULL,   // buffer
39                                       0,      // maxBufLen
40                                       &out_size);
41  if (converted == 0 || out_size == 0)
42    return StringType();
43
44  // out_size is the number of UInt8-sized units needed in the destination.
45  // A buffer allocated as UInt8 units might not be properly aligned to
46  // contain elements of StringType::value_type.  Use a container for the
47  // proper value_type, and convert out_size by figuring the number of
48  // value_type elements per UInt8.  Leave room for a NUL terminator.
49  typename StringType::size_type elements =
50      out_size * sizeof(UInt8) / sizeof(typename StringType::value_type) + 1;
51
52  std::vector<typename StringType::value_type> out_buffer(elements);
53  converted = CFStringGetBytes(cfstring,
54                               whole_string,
55                               encoding,
56                               0,      // lossByte
57                               false,  // isExternalRepresentation
58                               reinterpret_cast<UInt8*>(&out_buffer[0]),
59                               out_size,
60                               NULL);  // usedBufLen
61  if (converted == 0)
62    return StringType();
63
64  out_buffer[elements - 1] = '\0';
65  return StringType(&out_buffer[0], elements - 1);
66}
67
68// Given an STL string |in| with an encoding specified by |in_encoding|,
69// convert it to |out_encoding| and return it as an STL string of the
70// |OutStringType| template type.  Returns an empty string on failure.
71//
72// Do not assert in this function since it is used by the asssertion code!
73template<typename InStringType, typename OutStringType>
74static OutStringType STLStringToSTLStringWithEncodingsT(
75    const InStringType& in,
76    CFStringEncoding in_encoding,
77    CFStringEncoding out_encoding) {
78  typename InStringType::size_type in_length = in.length();
79  if (in_length == 0)
80    return OutStringType();
81
82  base::ScopedCFTypeRef<CFStringRef> cfstring(CFStringCreateWithBytesNoCopy(
83      NULL,
84      reinterpret_cast<const UInt8*>(in.data()),
85      in_length * sizeof(typename InStringType::value_type),
86      in_encoding,
87      false,
88      kCFAllocatorNull));
89  if (!cfstring)
90    return OutStringType();
91
92  return CFStringToSTLStringWithEncodingT<OutStringType>(cfstring,
93                                                         out_encoding);
94}
95
96// Given an STL string |in| with an encoding specified by |in_encoding|,
97// return it as a CFStringRef.  Returns NULL on failure.
98template<typename StringType>
99static CFStringRef STLStringToCFStringWithEncodingsT(
100    const StringType& in,
101    CFStringEncoding in_encoding) {
102  typename StringType::size_type in_length = in.length();
103  if (in_length == 0)
104    return CFSTR("");
105
106  return CFStringCreateWithBytes(kCFAllocatorDefault,
107                                 reinterpret_cast<const UInt8*>(in.data()),
108                                 in_length *
109                                   sizeof(typename StringType::value_type),
110                                 in_encoding,
111                                 false);
112}
113
114// Specify the byte ordering explicitly, otherwise CFString will be confused
115// when strings don't carry BOMs, as they typically won't.
116static const CFStringEncoding kNarrowStringEncoding = kCFStringEncodingUTF8;
117#ifdef __BIG_ENDIAN__
118static const CFStringEncoding kMediumStringEncoding = kCFStringEncodingUTF16BE;
119static const CFStringEncoding kWideStringEncoding = kCFStringEncodingUTF32BE;
120#elif defined(__LITTLE_ENDIAN__)
121static const CFStringEncoding kMediumStringEncoding = kCFStringEncodingUTF16LE;
122static const CFStringEncoding kWideStringEncoding = kCFStringEncodingUTF32LE;
123#endif  // __LITTLE_ENDIAN__
124
125}  // namespace
126
127// Do not assert in this function since it is used by the asssertion code!
128std::string SysWideToUTF8(const std::wstring& wide) {
129  return STLStringToSTLStringWithEncodingsT<std::wstring, std::string>(
130      wide, kWideStringEncoding, kNarrowStringEncoding);
131}
132
133// Do not assert in this function since it is used by the asssertion code!
134std::wstring SysUTF8ToWide(const StringPiece& utf8) {
135  return STLStringToSTLStringWithEncodingsT<StringPiece, std::wstring>(
136      utf8, kNarrowStringEncoding, kWideStringEncoding);
137}
138
139std::string SysWideToNativeMB(const std::wstring& wide) {
140  return SysWideToUTF8(wide);
141}
142
143std::wstring SysNativeMBToWide(const StringPiece& native_mb) {
144  return SysUTF8ToWide(native_mb);
145}
146
147CFStringRef SysUTF8ToCFStringRef(const std::string& utf8) {
148  return STLStringToCFStringWithEncodingsT(utf8, kNarrowStringEncoding);
149}
150
151CFStringRef SysUTF16ToCFStringRef(const string16& utf16) {
152  return STLStringToCFStringWithEncodingsT(utf16, kMediumStringEncoding);
153}
154
155NSString* SysUTF8ToNSString(const std::string& utf8) {
156  return (NSString*)base::mac::CFTypeRefToNSObjectAutorelease(
157      SysUTF8ToCFStringRef(utf8));
158}
159
160NSString* SysUTF16ToNSString(const string16& utf16) {
161  return (NSString*)base::mac::CFTypeRefToNSObjectAutorelease(
162      SysUTF16ToCFStringRef(utf16));
163}
164
165std::string SysCFStringRefToUTF8(CFStringRef ref) {
166  return CFStringToSTLStringWithEncodingT<std::string>(ref,
167                                                       kNarrowStringEncoding);
168}
169
170string16 SysCFStringRefToUTF16(CFStringRef ref) {
171  return CFStringToSTLStringWithEncodingT<string16>(ref,
172                                                    kMediumStringEncoding);
173}
174
175std::string SysNSStringToUTF8(NSString* nsstring) {
176  if (!nsstring)
177    return std::string();
178  return SysCFStringRefToUTF8(reinterpret_cast<CFStringRef>(nsstring));
179}
180
181string16 SysNSStringToUTF16(NSString* nsstring) {
182  if (!nsstring)
183    return string16();
184  return SysCFStringRefToUTF16(reinterpret_cast<CFStringRef>(nsstring));
185}
186
187}  // namespace base
188