[LSC] Replace base::string16 with std::u16string in //[f-z]*

This change replaces base::string16 with std::u16string in //[f-z]*

Reproduction steps:
$ git grep -lw 'base::string16' [f-z]* | \
      xargs sed -i 's/\bbase::string16\b/std::u16string/g'
$ git cl format

Bug: 1184339
Change-Id: I4e0ff2fd300c9fd9360dbf8f4b44e74f5f511797
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2752148
Commit-Queue: Jan Wilken Dörrie <jdoerrie@chromium.org>
Owners-Override: Jan Wilken Dörrie <jdoerrie@chromium.org>
Owners-Override: danakj <danakj@chromium.org>
Auto-Submit: Jan Wilken Dörrie <jdoerrie@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#862044}

fuchsia/base/mem_buffer_util.cc

@@ -20,7 +20,7 @@
 namespace cr_fuchsia {
 
 bool ReadUTF8FromVMOAsUTF16(const fuchsia::mem::Buffer& buffer,
-                            base::string16* output) {
+                            std::u16string* output) {
   std::string output_utf8;
   if (!StringFromMemBuffer(buffer, &output_utf8))
     return false;

fuchsia/base/mem_buffer_util.h

@@ -19,7 +19,7 @@ namespace cr_fuchsia {
 // Reads the contents of |buffer|, encoded in UTF-8, to a UTF-16 string.
 // Returns |false| if |buffer| is not valid UTF-8.
 bool ReadUTF8FromVMOAsUTF16(const fuchsia::mem::Buffer& buffer,
-                            base::string16* output);
+                            std::u16string* output);
 
 // Creates a Fuchsia memory buffer from |data|.
 fuchsia::mem::Buffer MemBufferFromString(base::StringPiece data,

fuchsia/base/message_port.cc

@@ -35,7 +35,7 @@ base::Optional<fuchsia::web::FrameError> BlinkMessageFromFidl(
     return fuchsia::web::FrameError::NO_DATA_IN_MESSAGE;
   }
 
-  base::string16 data_utf16;
+  std::u16string data_utf16;
   if (!cr_fuchsia::ReadUTF8FromVMOAsUTF16(fidl_message.data(), &data_utf16)) {
     return fuchsia::web::FrameError::BUFFER_NOT_UTF8;
   }
@@ -359,7 +359,7 @@ base::Optional<fuchsia::web::WebMessage> FidlWebMessageFromBlink(
     blink_message.ports.clear();
   }
 
-  base::string16 data_utf16 = std::move(blink_message.data);
+  std::u16string data_utf16 = std::move(blink_message.data);
   std::string data_utf8;
   if (!base::UTF16ToUTF8(data_utf16.data(), data_utf16.size(), &data_utf8))
     return base::nullopt;

fuchsia/engine/browser/frame_impl.cc

@@ -328,7 +328,7 @@ void FrameImpl::ExecuteJavaScriptInternal(std::vector<std::string> origins,
     return;
   }
 
-  base::string16 script_utf16;
+  std::u16string script_utf16;
   if (!cr_fuchsia::ReadUTF8FromVMOAsUTF16(script, &script_utf16)) {
     result.set_err(fuchsia::web::FrameError::BUFFER_NOT_UTF8);
     callback(std::move(result));
@@ -720,11 +720,11 @@ void FrameImpl::PostMessage(std::string origin,
     return;
   }
 
-  base::Optional<base::string16> origin_utf16;
+  base::Optional<std::u16string> origin_utf16;
   if (origin != kWildcardOrigin)
     origin_utf16 = base::UTF8ToUTF16(origin);
 
-  base::string16 data_utf16;
+  std::u16string data_utf16;
   if (!cr_fuchsia::ReadUTF8FromVMOAsUTF16(message.data(), &data_utf16)) {
     result.set_err(fuchsia::web::FrameError::BUFFER_NOT_UTF8);
     callback(std::move(result));
@@ -757,7 +757,7 @@ void FrameImpl::PostMessage(std::string origin,
   }
 
   content::MessagePortProvider::PostMessageToFrame(
-      web_contents_.get(), base::string16(), origin_utf16,
+      web_contents_.get(), std::u16string(), origin_utf16,
       std::move(data_utf16), std::move(message_ports));
   result.set_response(fuchsia::web::Frame_PostMessage_Response());
   callback(std::move(result));
@@ -1005,9 +1005,9 @@ void FrameImpl::SetBlockMediaLoading(bool blocked) {
 bool FrameImpl::DidAddMessageToConsole(
     content::WebContents* source,
     blink::mojom::ConsoleMessageLevel log_level,
-    const base::string16& message,
+    const std::u16string& message,
     int32_t line_no,
-    const base::string16& source_id) {
+    const std::u16string& source_id) {
   fx_log_severity_t severity =
       BlinkConsoleMessageLevelToFxLogSeverity(log_level);
   if (severity < log_level_) {

fuchsia/engine/browser/frame_impl.h

@@ -227,9 +227,9 @@ class FrameImpl : public fuchsia::web::Frame,
   void CloseContents(content::WebContents* source) override;
   bool DidAddMessageToConsole(content::WebContents* source,
                               blink::mojom::ConsoleMessageLevel log_level,
-                              const base::string16& message,
+                              const std::u16string& message,
                               int32_t line_no,
-                              const base::string16& source_id) override;
+                              const std::u16string& source_id) override;
   bool IsWebContentsCreationOverridden(
       content::SiteInstance* source_site_instance,
       content::mojom::WindowContainerType window_container_type,

fuchsia/engine/common/web_engine_content_client.cc

@@ -14,7 +14,7 @@
 WebEngineContentClient::WebEngineContentClient() = default;
 WebEngineContentClient::~WebEngineContentClient() = default;
 
-base::string16 WebEngineContentClient::GetLocalizedString(int message_id) {
+std::u16string WebEngineContentClient::GetLocalizedString(int message_id) {
   return l10n_util::GetStringUTF16(message_id);
 }
 

fuchsia/engine/common/web_engine_content_client.h

@@ -14,7 +14,7 @@ class WebEngineContentClient : public content::ContentClient {
   ~WebEngineContentClient() override;
 
   // content::ContentClient implementation.
-  base::string16 GetLocalizedString(int message_id) override;
+  std::u16string GetLocalizedString(int message_id) override;
   base::StringPiece GetDataResource(int resource_id,
                                     ui::ScaleFactor scale_factor) override;
   base::RefCountedMemory* GetDataResourceBytes(int resource_id) override;

gin/converter.cc

@@ -152,17 +152,17 @@ bool Converter<std::string>::FromV8(Isolate* isolate,
   return true;
 }
 
-Local<Value> Converter<base::string16>::ToV8(Isolate* isolate,
-                                             const base::string16& val) {
+Local<Value> Converter<std::u16string>::ToV8(Isolate* isolate,
+                                             const std::u16string& val) {
   return String::NewFromTwoByte(isolate,
                                 reinterpret_cast<const uint16_t*>(val.data()),
                                 v8::NewStringType::kNormal, val.size())
       .ToLocalChecked();
 }
 
-bool Converter<base::string16>::FromV8(Isolate* isolate,
+bool Converter<std::u16string>::FromV8(Isolate* isolate,
                                        Local<Value> val,
-                                       base::string16* out) {
+                                       std::u16string* out) {
   if (!val->IsString())
     return false;
   Local<String> str = Local<String>::Cast(val);

gin/converter.h

@@ -123,12 +123,12 @@ struct GIN_EXPORT Converter<std::string> {
 };
 
 template <>
-struct GIN_EXPORT Converter<base::string16> {
+struct GIN_EXPORT Converter<std::u16string> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   const base::string16& val);
+                                   const std::u16string& val);
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
-                     base::string16* out);
+                     std::u16string* out);
 };
 
 template <>

gin/converter_unittest.cc

@@ -89,22 +89,22 @@ TEST_F(ConverterTest, String16) {
 
   HandleScope handle_scope(isolate);
 
-  EXPECT_TRUE(Converter<base::string16>::ToV8(isolate, base::ASCIIToUTF16(""))
+  EXPECT_TRUE(Converter<std::u16string>::ToV8(isolate, base::ASCIIToUTF16(""))
                   ->StrictEquals(StringToV8(isolate, "")));
   EXPECT_TRUE(
-      Converter<base::string16>::ToV8(isolate, base::ASCIIToUTF16("hello"))
+      Converter<std::u16string>::ToV8(isolate, base::ASCIIToUTF16("hello"))
           ->StrictEquals(StringToV8(isolate, "hello")));
 
-  base::string16 result;
+  std::u16string result;
 
   ASSERT_FALSE(
-      Converter<base::string16>::FromV8(isolate, v8::False(isolate), &result));
+      Converter<std::u16string>::FromV8(isolate, v8::False(isolate), &result));
   ASSERT_FALSE(
-      Converter<base::string16>::FromV8(isolate, v8::True(isolate), &result));
-  ASSERT_TRUE(Converter<base::string16>::FromV8(
+      Converter<std::u16string>::FromV8(isolate, v8::True(isolate), &result));
+  ASSERT_TRUE(Converter<std::u16string>::FromV8(
       isolate, v8::String::Empty(isolate), &result));
-  EXPECT_EQ(result, base::string16());
-  ASSERT_TRUE(Converter<base::string16>::FromV8(
+  EXPECT_EQ(result, std::u16string());
+  ASSERT_TRUE(Converter<std::u16string>::FromV8(
       isolate, StringToV8(isolate, "hello"), &result));
   EXPECT_EQ(result, base::ASCIIToUTF16("hello"));
 }

headless/lib/browser/headless_clipboard.cc

@@ -48,7 +48,7 @@ void HeadlessClipboard::Clear(ui::ClipboardBuffer buffer) {
 void HeadlessClipboard::ReadAvailableTypes(
     ui::ClipboardBuffer buffer,
     const ui::DataTransferEndpoint* data_dst,
-    std::vector<base::string16>* types) const {
+    std::vector<std::u16string>* types) const {
   DCHECK(types);
   types->clear();
 
@@ -69,15 +69,15 @@ void HeadlessClipboard::ReadAvailableTypes(
 
 // |data_dst| is not used. It's only passed to be consistent with other
 // platforms.
-std::vector<base::string16>
+std::vector<std::u16string>
 HeadlessClipboard::ReadAvailablePlatformSpecificFormatNames(
     ui::ClipboardBuffer buffer,
     const ui::DataTransferEndpoint* data_dst) const {
   const auto& data = GetStore(buffer).data;
-  std::vector<base::string16> types;
+  std::vector<std::u16string> types;
   types.reserve(data.size());
   for (const auto& it : data) {
-    base::string16 type = base::UTF8ToUTF16(it.first.GetName());
+    std::u16string type = base::UTF8ToUTF16(it.first.GetName());
     types.push_back(type);
   }
 
@@ -88,7 +88,7 @@ HeadlessClipboard::ReadAvailablePlatformSpecificFormatNames(
 // platforms.
 void HeadlessClipboard::ReadText(ui::ClipboardBuffer buffer,
                                  const ui::DataTransferEndpoint* data_dst,
-                                 base::string16* result) const {
+                                 std::u16string* result) const {
   std::string result8;
   ReadAsciiText(buffer, data_dst, &result8);
   *result = base::UTF8ToUTF16(result8);
@@ -110,7 +110,7 @@ void HeadlessClipboard::ReadAsciiText(ui::ClipboardBuffer buffer,
 // platforms.
 void HeadlessClipboard::ReadHTML(ui::ClipboardBuffer buffer,
                                  const ui::DataTransferEndpoint* data_dst,
-                                 base::string16* markup,
+                                 std::u16string* markup,
                                  std::string* src_url,
                                  uint32_t* fragment_start,
                                  uint32_t* fragment_end) const {
@@ -129,7 +129,7 @@ void HeadlessClipboard::ReadHTML(ui::ClipboardBuffer buffer,
 // platforms.
 void HeadlessClipboard::ReadSvg(ui::ClipboardBuffer buffer,
                                 const ui::DataTransferEndpoint* data_dst,
-                                base::string16* result) const {
+                                std::u16string* result) const {
   result->clear();
   const DataStore& store = GetStore(buffer);
   auto it = store.data.find(ui::ClipboardFormatType::GetSvgType());
@@ -160,9 +160,9 @@ void HeadlessClipboard::ReadImage(ui::ClipboardBuffer buffer,
 // |data_dst| is not used. It's only passed to be consistent with other
 // platforms.
 void HeadlessClipboard::ReadCustomData(ui::ClipboardBuffer clipboard_buffer,
-                                       const base::string16& type,
+                                       const std::u16string& type,
                                        const ui::DataTransferEndpoint* data_dst,
-                                       base::string16* result) const {}
+                                       std::u16string* result) const {}
 
 // |data_dst| is not used. It's only passed to be consistent with other
 // platforms.
@@ -175,7 +175,7 @@ void HeadlessClipboard::ReadFilenames(ui::ClipboardBuffer buffer,
 // |data_dst| is not used. It's only passed to be consistent with other
 // platforms.
 void HeadlessClipboard::ReadBookmark(const ui::DataTransferEndpoint* data_dst,
-                                     base::string16* title,
+                                     std::u16string* title,
                                      std::string* url) const {
   const DataStore& store = GetDefaultStore();
   auto it = store.data.find(ui::ClipboardFormatType::GetUrlType());
@@ -240,7 +240,7 @@ void HeadlessClipboard::WriteHTML(const char* markup_data,
                                   size_t markup_len,
                                   const char* url_data,
                                   size_t url_len) {
-  base::string16 markup;
+  std::u16string markup;
   base::UTF8ToUTF16(markup_data, markup_len, &markup);
   GetDefaultStore().data[ui::ClipboardFormatType::GetHtmlType()] =
       base::UTF16ToUTF8(markup);

headless/lib/browser/headless_clipboard.h

@@ -35,40 +35,40 @@ class HeadlessClipboard : public ui::Clipboard {
   void Clear(ui::ClipboardBuffer buffer) override;
   void ReadAvailableTypes(ui::ClipboardBuffer buffer,
                           const ui::DataTransferEndpoint* data_dst,
-                          std::vector<base::string16>* types) const override;
-  std::vector<base::string16> ReadAvailablePlatformSpecificFormatNames(
+                          std::vector<std::u16string>* types) const override;
+  std::vector<std::u16string> ReadAvailablePlatformSpecificFormatNames(
       ui::ClipboardBuffer buffer,
       const ui::DataTransferEndpoint* data_dst) const override;
   void ReadText(ui::ClipboardBuffer buffer,
                 const ui::DataTransferEndpoint* data_dst,
-                base::string16* result) const override;
+                std::u16string* result) const override;
   void ReadAsciiText(ui::ClipboardBuffer buffer,
                      const ui::DataTransferEndpoint* data_dst,
                      std::string* result) const override;
   void ReadHTML(ui::ClipboardBuffer buffer,
                 const ui::DataTransferEndpoint* data_dst,
-                base::string16* markup,
+                std::u16string* markup,
                 std::string* src_url,
                 uint32_t* fragment_start,
                 uint32_t* fragment_end) const override;
   void ReadSvg(ui::ClipboardBuffer buffer,
                const ui::DataTransferEndpoint* data_dst,
-               base::string16* result) const override;
+               std::u16string* result) const override;
   void ReadRTF(ui::ClipboardBuffer buffer,
                const ui::DataTransferEndpoint* data_dst,
                std::string* result) const override;
   void ReadImage(ui::ClipboardBuffer buffer,
                  const ui::DataTransferEndpoint* data_dst,
                  ReadImageCallback callback) const override;
   void ReadCustomData(ui::ClipboardBuffer clipboard_buffer,
-                      const base::string16& type,
+                      const std::u16string& type,
                       const ui::DataTransferEndpoint* data_dst,
-                      base::string16* result) const override;
+                      std::u16string* result) const override;
   void ReadFilenames(ui::ClipboardBuffer buffer,
                      const ui::DataTransferEndpoint* data_dst,
                      std::vector<ui::FileInfo>* result) const override;
   void ReadBookmark(const ui::DataTransferEndpoint* data_dst,
-                    base::string16* title,
+                    std::u16string* title,
                     std::string* url) const override;
   void ReadData(const ui::ClipboardFormatType& format,
                 const ui::DataTransferEndpoint* data_dst,

headless/lib/headless_content_client.cc

@@ -14,7 +14,7 @@ HeadlessContentClient::HeadlessContentClient() = default;
 
 HeadlessContentClient::~HeadlessContentClient() = default;
 
-base::string16 HeadlessContentClient::GetLocalizedString(int message_id) {
+std::u16string HeadlessContentClient::GetLocalizedString(int message_id) {
   return l10n_util::GetStringUTF16(message_id);
 }
 

headless/lib/headless_content_client.h

@@ -22,7 +22,7 @@ class HeadlessContentClient : public content::ContentClient {
   ~HeadlessContentClient() override;
 
   // content::ContentClient implementation:
-  base::string16 GetLocalizedString(int message_id) override;
+  std::u16string GetLocalizedString(int message_id) override;
   base::StringPiece GetDataResource(int resource_id,
                                     ui::ScaleFactor scale_factor) override;
   base::RefCountedMemory* GetDataResourceBytes(int resource_id) override;

headless/test/headless_browser_browsertest.cc

@@ -265,7 +265,7 @@ IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, ClipboardCopyPasteText) {
   // Tests copy-pasting text with the clipboard in headless mode.
   ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
   ASSERT_TRUE(clipboard);
-  base::string16 paste_text = base::ASCIIToUTF16("Clippy!");
+  std::u16string paste_text = base::ASCIIToUTF16("Clippy!");
   for (ui::ClipboardBuffer buffer :
        {ui::ClipboardBuffer::kCopyPaste, ui::ClipboardBuffer::kSelection,
         ui::ClipboardBuffer::kDrag}) {
@@ -275,7 +275,7 @@ IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, ClipboardCopyPasteText) {
       ui::ScopedClipboardWriter writer(buffer);
       writer.WriteText(paste_text);
     }
-    base::string16 copy_text;
+    std::u16string copy_text;
     clipboard->ReadText(buffer, /* data_dst = */ nullptr, &copy_text);
     EXPECT_EQ(paste_text, copy_text);
   }

ios/chrome/app/application_delegate/user_activity_handler.mm

@@ -444,7 +444,7 @@ + (GURL)generateResultGURLFromSearchQuery:(NSString*)searchQuery
   DCHECK(!defaultURL->url().empty());
   DCHECK(
       defaultURL->url_ref().IsValid(templateURLService->search_terms_data()));
-  base::string16 queryString = base::SysNSStringToUTF16(searchQuery);
+  std::u16string queryString = base::SysNSStringToUTF16(searchQuery);
   TemplateURLRef::SearchTermsArgs search_args(queryString);
 
   GURL result(defaultURL->url_ref().ReplaceSearchTerms(

ios/chrome/browser/accessibility/window_accessibility_change_notifier_app_agent.mm

@@ -122,10 +122,10 @@ - (void)notifyWindowCount {
   // are showing.
   if (previousWindowCount != self.visibleWindowCount &&
       self.visibleWindowCount > 0) {
-    base::string16 pattern =
+    std::u16string pattern =
         l10n_util::GetStringUTF16(IDS_IOS_WINDOW_COUNT_CHANGE);
     int numberOfWindows = static_cast<int>(self.visibleWindowCount);
-    base::string16 formattedMessage =
+    std::u16string formattedMessage =
         base::i18n::MessageFormatter::FormatWithNamedArgs(pattern, "count",
                                                           numberOfWindows);
 

ios/chrome/browser/autocomplete/autocomplete_provider_client_impl.h

@@ -53,8 +53,8 @@ class AutocompleteProviderClientImpl : public AutocompleteProviderClient {
       const override;
   std::string GetAcceptLanguages() const override;
   std::string GetEmbedderRepresentationOfAboutScheme() const override;
-  std::vector<base::string16> GetBuiltinURLs() override;
-  std::vector<base::string16> GetBuiltinsToProvideAsUserTypes() override;
+  std::vector<std::u16string> GetBuiltinURLs() override;
+  std::vector<std::u16string> GetBuiltinsToProvideAsUserTypes() override;
   component_updater::ComponentUpdateService* GetComponentUpdateService()
       override;
   signin::IdentityManager* GetIdentityManager() const override;
@@ -64,15 +64,15 @@ class AutocompleteProviderClientImpl : public AutocompleteProviderClient {
   bool IsAuthenticated() const override;
   bool IsSyncActive() const override;
   void Classify(
-      const base::string16& text,
+      const std::u16string& text,
       bool prefer_keyword,
       bool allow_exact_keyword_match,
       metrics::OmniboxEventProto::PageClassification page_classification,
       AutocompleteMatch* match,
       GURL* alternate_nav_url) override;
   void DeleteMatchingURLsForKeywordFromHistory(
       history::KeywordID keyword_id,
-      const base::string16& term) override;
+      const std::u16string& term) override;
   void PrefetchImage(const GURL& url) override;
   bool IsTabOpenWithURL(const GURL& url,
                         const AutocompleteInput* input) override;