[base] Prepare non-Windows code for string16 switch

This change prepares the non-Windows part of the codebase for the
base::string16 switch to std::u16string. This is done by adding explicit
casts where current code relies on base::char16 being int16_t.

Furthermore, WTF::String, WTF::StringView and WTF::AtomicString are
modified to only expose a constructor from const char16_t* when char16_t
and icu's UChar are different types.

Lastly, this change removes a couple banned usages of NoCopy creation of
(Core)Foundation type. Apart from that this change does not change any
functionality.

TBR=jbroman,mmenke,jamiewalch

Bug: 911896
Change-Id: Ie208e7a5e7f00097d0a07eb4fd9197284cd8c482
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2596261Reviewed-by: Jamie Walch <jamiewalch@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Reviewed-by: Jeremy Roman <jbroman@chromium.org>
Reviewed-by: Matt Mueller <mattm@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Jan Wilken Dörrie <jdoerrie@chromium.org>
Cr-Commit-Position: refs/heads/master@{#838264}

chrome/browser/history/android/sqlite_cursor.cc

@@ -79,8 +79,9 @@ ScopedJavaLocalRef<jstring> SQLiteCursor::GetString(
     const JavaParamRef<jobject>& obj,
     jint column) {
   base::string16 value = statement_->statement()->ColumnString16(column);
-  return ScopedJavaLocalRef<jstring>(env,
-      env->NewString(value.data(), value.size()));
+  return ScopedJavaLocalRef<jstring>(
+      env, env->NewString(reinterpret_cast<const jchar*>(value.data()),
+                          value.size()));
 }
 
 jlong SQLiteCursor::GetLong(JNIEnv* env,

chrome/utility/safe_browsing/mac/hfs.cc

@@ -23,7 +23,7 @@ namespace safe_browsing {
 namespace dmg {
 
 // UTF-16 character for file path seprator.
-static const uint16_t kFilePathSeparator = '/';
+static const base::char16 kFilePathSeparator = '/';
 
 static void ConvertBigEndian(HFSPlusForkData* fork) {
   ConvertBigEndian(&fork->logicalSize);

content/browser/renderer_host/input/web_input_event_builders_mac.mm

@@ -309,8 +309,9 @@ blink::WebKeyboardEvent WebKeyboardEventBuilder::Build(NSEvent* event,
 
   if ([text_str length] < blink::WebKeyboardEvent::kTextLengthCap &&
       [unmodified_str length] < blink::WebKeyboardEvent::kTextLengthCap) {
-    [text_str getCharacters:&result.text[0]];
-    [unmodified_str getCharacters:&result.unmodified_text[0]];
+    [text_str getCharacters:reinterpret_cast<UniChar*>(&result.text[0])];
+    [unmodified_str
+        getCharacters:reinterpret_cast<UniChar*>(&result.unmodified_text[0])];
   } else
     NOTIMPLEMENTED();
 

content/browser/renderer_host/native_web_keyboard_event_mac.mm

@@ -69,11 +69,12 @@ NativeWebKeyboardEvent::NativeWebKeyboardEvent(
   if (unmod_text_length == 0)
     type = NSFlagsChanged;
 
-  NSString* text =
-      [[[NSString alloc] initWithCharacters:web_event.text length:text_length]
-          autorelease];
+  NSString* text = [[[NSString alloc]
+      initWithCharacters:reinterpret_cast<const UniChar*>(web_event.text)
+                  length:text_length] autorelease];
   NSString* unmodified_text =
-      [[[NSString alloc] initWithCharacters:web_event.unmodified_text
+      [[[NSString alloc] initWithCharacters:reinterpret_cast<const UniChar*>(
+                                                web_event.unmodified_text)
                                      length:unmod_text_length] autorelease];
 
   os_event = [[NSEvent keyEventWithType:type

net/base/net_string_util_icu_alternatives_android.cc

@@ -121,7 +121,8 @@ bool ToUpper(base::StringPiece16 str, base::string16* output) {
   output->clear();
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jstring> java_new_str(
-      env, env->NewString(str.data(), str.length()));
+      env,
+      env->NewString(reinterpret_cast<const jchar*>(str.data()), str.length()));
   if (java_new_str.is_null())
     return false;
   ScopedJavaLocalRef<jstring> java_result =

net/third_party/mozilla_security_manager/nsPKCS12Blob.cpp

@@ -54,11 +54,10 @@ namespace {
 
 // unicodeToItem
 //
-// For the NSS PKCS#12 library, must convert PRUnichars (shorts) to
+// For the NSS PKCS#12 library, must convert base::char16s (shorts) to
 // a buffer of octets.  Must handle byte order correctly.
 // TODO: Is there a Mozilla way to do this?  In the string lib?
-void unicodeToItem(const PRUnichar *uni, SECItem *item)
-{
+void unicodeToItem(const base::char16* uni, SECItem* item) {
   int len = 0;
   while (uni[len++] != 0);
   SECITEM_AllocItem(NULL, item, sizeof(PRUnichar) * len);

remoting/host/input_injector_mac.cc

@@ -50,7 +50,9 @@ void CreateAndPostKeyEvent(int keycode,
   if (eventRef) {
     CGEventSetFlags(eventRef, static_cast<CGEventFlags>(flags));
     if (!unicode.empty())
-      CGEventKeyboardSetUnicodeString(eventRef, unicode.size(), &(unicode[0]));
+      CGEventKeyboardSetUnicodeString(
+          eventRef, unicode.size(),
+          reinterpret_cast<const UniChar*>(unicode.data()));
     CGEventPost(kCGSessionEventTap, eventRef);
   }
 }

remoting/host/keyboard_layout_monitor_mac.cc

@@ -204,7 +204,9 @@ void KeyboardLayoutMonitorMac::QueryLayoutOnMainLoop(
       }
 
       key_actions[shift_level].set_character(
-          base::UTF16ToUTF8(base::StringPiece16(result_array, result_length)));
+          base::UTF16ToUTF8(base::StringPiece16(
+              reinterpret_cast<const base::char16*>(result_array),
+              result_length)));
     }
 
     if (key_actions.size() == 0) {

third_party/blink/renderer/core/editing/substring_util.mm

@@ -124,7 +124,8 @@ NSAttributedString* AttributedSubstringFromRange(const EphemeralRange& range,
     String characters = it.GetTextState().GetTextForTesting();
     characters.Ensure16Bit();
     NSString* substring =
-        [[[NSString alloc] initWithCharacters:characters.Characters16()
+        [[[NSString alloc] initWithCharacters:reinterpret_cast<const UniChar*>(
+                                                  characters.Characters16())
                                        length:characters.length()] autorelease];
     [string replaceCharactersInRange:NSMakeRange(position, 0)
                           withString:substring];

third_party/blink/renderer/platform/fonts/mac/font_cache_mac.mm

@@ -140,16 +140,14 @@ scoped_refptr<SimpleFontData> FontCache::PlatformFallbackFontForCharacter(
       font_data_to_substitute->PlatformData();
   NSFont* ns_font = base::mac::CFToNSCast(platform_data.CtFont());
 
-  NSString* string =
-      [[NSString alloc] initWithCharactersNoCopy:code_units
-                                          length:code_units_length
-                                    freeWhenDone:NO];
+  NSString* string = [[[NSString alloc]
+      initWithCharacters:reinterpret_cast<UniChar*>(code_units)
+                  length:code_units_length] autorelease];
   NSFont* substitute_font =
       [NSFont findFontLike:ns_font
                  forString:string
                  withRange:NSMakeRange(0, code_units_length)
                 inLanguage:nil];
-  [string release];
 
   // FIXME: Remove this SPI usage: http://crbug.com/255122
   if (!substitute_font && code_units_length == 1)

third_party/blink/renderer/platform/wtf/text/atomic_string.h

@@ -23,6 +23,7 @@
 
 #include <cstring>
 #include <iosfwd>
+#include <type_traits>
 
 #include "build/build_config.h"
 #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
@@ -74,6 +75,10 @@ class WTF_EXPORT AtomicString {
   AtomicString(const LChar* chars, unsigned length);
   AtomicString(const UChar* chars, unsigned length);
   AtomicString(const UChar* chars);
+  // TODO(crbug.com/911896): Remove this constructor once `UChar` is `char16_t`
+  // on all platforms.
+  template <typename UCharT = UChar,
+            typename = std::enable_if_t<!std::is_same<UCharT, char16_t>::value>>
   AtomicString(const char16_t* chars)
       : AtomicString(reinterpret_cast<const UChar*>(chars)) {}
 

third_party/blink/renderer/platform/wtf/text/string_mac.mm

@@ -45,7 +45,8 @@ String::String(NSString* str) {
 
     Vector<UChar, 1024> uchar_buffer(size);
     CFStringGetCharacters(reinterpret_cast<CFStringRef>(str),
-                          CFRangeMake(0, size), uchar_buffer.data());
+                          CFRangeMake(0, size),
+                          reinterpret_cast<UniChar*>(uchar_buffer.data()));
     impl_ = StringImpl::Create(uchar_buffer.data(), size);
   }
 }

third_party/blink/renderer/platform/wtf/text/string_view.h

@@ -11,6 +11,8 @@
 #include "base/memory/scoped_refptr.h"
 #endif
 #include <cstring>
+#include <type_traits>
+
 #include "base/containers/span.h"
 #include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 #include "third_party/blink/renderer/platform/wtf/text/string_impl.h"
@@ -126,6 +128,10 @@ class WTF_EXPORT StringView {
   StringView(const UChar* chars, unsigned length)
       : impl_(StringImpl::empty16_bit_), bytes_(chars), length_(length) {}
   StringView(const UChar* chars);
+  // TODO(crbug.com/911896): Remove this constructor once `UChar` is `char16_t`
+  // on all platforms.
+  template <typename UCharT = UChar,
+            typename = std::enable_if_t<!std::is_same<UCharT, char16_t>::value>>
   StringView(const char16_t* chars)
       : StringView(reinterpret_cast<const UChar*>(chars)) {}
 

third_party/blink/renderer/platform/wtf/text/wtf_string.h

@@ -27,6 +27,8 @@
 // on systems without case-sensitive file systems.
 
 #include <iosfwd>
+#include <type_traits>
+
 #include "base/containers/span.h"
 #include "build/build_config.h"
 #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
@@ -80,6 +82,10 @@ class WTF_EXPORT String {
 
   // Construct a string with UTF-16 data, from a null-terminated source.
   String(const UChar*);
+  // TODO(crbug.com/911896): Remove this constructor once `UChar` is `char16_t`
+  // on all platforms.
+  template <typename UCharT = UChar,
+            typename = std::enable_if_t<!std::is_same<UCharT, char16_t>::value>>
   String(const char16_t* chars)
       : String(reinterpret_cast<const UChar*>(chars)) {}
 

ui/base/x/selection_utils.cc

@@ -197,8 +197,8 @@ base::string16 SelectionData::GetHtml() const {
 
     // If the data starts with 0xFEFF, i.e., Byte Order Mark, assume it is
     // UTF-16, otherwise assume UTF-8.
-    if (size >= 2 && reinterpret_cast<const uint16_t*>(data)[0] == 0xFEFF) {
-      markup.assign(reinterpret_cast<const uint16_t*>(data) + 1,
+    if (size >= 2 && reinterpret_cast<const base::char16*>(data)[0] == 0xFEFF) {
+      markup.assign(reinterpret_cast<const base::char16*>(data) + 1,
                     (size / 2) - 1);
     } else {
       base::UTF8ToUTF16(reinterpret_cast<const char*>(data), size, &markup);

ui/views/style/platform_style_mac.mm

@@ -70,9 +70,9 @@ gfx::Range PlatformStyle::RangeToDeleteBackwards(const base::string16& text,
   if (cursor_position == 0)
     return gfx::Range();
 
-  base::ScopedCFTypeRef<CFStringRef> cf_string(
-      CFStringCreateWithCharactersNoCopy(kCFAllocatorDefault, text.data(),
-                                         text.size(), kCFAllocatorNull));
+  base::ScopedCFTypeRef<CFStringRef> cf_string(CFStringCreateWithCharacters(
+      kCFAllocatorDefault, reinterpret_cast<const UniChar*>(text.data()),
+      text.size()));
   CFRange range_to_delete = CFStringGetRangeOfCharacterClusterAtIndex(
       cf_string, cursor_position - 1, kCFStringBackwardDeletionCluster);