[ozone] Improved clipboard tests and de-duplicated string constants.

This CL pays a bit of technical debt in the clipboard implementation.

First, it updates a test that verifies that putting text into clipboard
registers the proper set of MIME types, as had been suggested in [1].

Second, it enables for Ozone the test that verifies selection buffers.

Third, it de-duplicates some string constants.

[1] https://chromium-review.googlesource.com/c/chromium/src/+/2306252

Change-Id: I6beb6b5b3827f0ec09cf19bc1868e7955141f680
Bug: 911992, 1105892
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2346338Reviewed-by: Scott Violet <sky@chromium.org>
Commit-Queue: Alexander Dunaev <adunaev@igalia.com>
Cr-Commit-Position: refs/heads/master@{#797572}

components/exo/data_offer.cc

@@ -31,8 +31,6 @@
 namespace exo {
 namespace {
 
-constexpr char kTextMimeTypeUtf8[] = "text/plain;charset=utf-8";
-constexpr char kUtf8String[] = "UTF8_STRING";
 constexpr char kTextMimeTypeUtf16[] = "text/plain;charset=utf-16";
 constexpr char kTextHtmlMimeTypeUtf8[] = "text/html;charset=utf-8";
 constexpr char kTextHtmlMimeTypeUtf16[] = "text/html;charset=utf-16";
@@ -279,7 +277,7 @@ void DataOffer::SetDropData(FileHelper* file_helper,
 
   base::string16 string_content;
   if (data.HasString() && data.GetString(&string_content)) {
-    const std::string utf8_mime_type = std::string(kTextMimeTypeUtf8);
+    const std::string utf8_mime_type = std::string(ui::kMimeTypeTextUtf8);
     data_.emplace(utf8_mime_type,
                   EncodeAsRefCountedString(string_content, kUTF8));
     delegate_->OnOffer(utf8_mime_type);
@@ -321,10 +319,11 @@ void DataOffer::SetClipboardData(FileHelper* file_helper,
                              /* data_dst = */ nullptr)) {
     auto utf8_callback =
         base::BindRepeating(&ReadTextFromClipboard, std::string(kUTF8));
-    delegate_->OnOffer(std::string(kTextMimeTypeUtf8));
-    data_callbacks_.emplace(std::string(kTextMimeTypeUtf8), utf8_callback);
-    delegate_->OnOffer(std::string(kUtf8String));
-    data_callbacks_.emplace(std::string(kUtf8String), utf8_callback);
+    delegate_->OnOffer(std::string(ui::kMimeTypeTextUtf8));
+    data_callbacks_.emplace(std::string(ui::kMimeTypeTextUtf8), utf8_callback);
+    delegate_->OnOffer(std::string(ui::kMimeTypeLinuxUtf8String));
+    data_callbacks_.emplace(std::string(ui::kMimeTypeLinuxUtf8String),
+                            utf8_callback);
     delegate_->OnOffer(std::string(kTextMimeTypeUtf16));
     data_callbacks_.emplace(
         std::string(kTextMimeTypeUtf16),

components/exo/data_source.cc

@@ -22,6 +22,7 @@
 #include "net/base/mime_util.h"
 #include "third_party/blink/public/common/mime_util/mime_util.h"
 #include "third_party/icu/source/common/unicode/ucnv.h"
+#include "ui/base/clipboard/clipboard_constants.h"
 
 namespace exo {
 
@@ -248,7 +249,7 @@ void DataSource::GetDataForPreferredMimeTypes(
 
   for (auto mime_type : mime_types_) {
     if (net::MatchesMimeType(std::string(kTextPlain), mime_type) ||
-        mime_type == kEncodingUTF8Legacy) {
+        mime_type == ui::kMimeTypeLinuxUtf8String) {
       if (text_reader.is_null())
         continue;
 

components/exo/mime_utils.cc

@@ -4,6 +4,8 @@
 
 #include "components/exo/mime_utils.h"
 
+#include "ui/base/clipboard/clipboard_constants.h"
+
 namespace {
 
 constexpr char kCharset[] = ";charset=";
@@ -16,7 +18,7 @@ namespace exo {
 
 std::string GetCharset(const std::string& mime_type) {
   // We special case UTF8_STRING to provide minimal handling of X11 apps.
-  if (mime_type == kEncodingUTF8Legacy)
+  if (mime_type == ui::kMimeTypeLinuxUtf8String)
     return std::string(kEncodingUTF8Charset);
 
   auto pos = mime_type.find(kCharset);

components/exo/mime_utils.h

@@ -9,8 +9,6 @@
 
 namespace exo {
 
-constexpr char kEncodingUTF8Legacy[] = "UTF8_STRING";
-
 // Takes a text/* mime type and returns the name of the character set specified
 // in the type. If no character set is specified, defaults to US-ASCII.
 std::string GetCharset(const std::string& mime_type);

ui/base/clipboard/clipboard_constants.cc

@@ -10,15 +10,12 @@ const char kMimeTypeText[] = "text/plain";
 const char kMimeTypeTextUtf8[] = "text/plain;charset=utf-8";
 const char kMimeTypeURIList[] = "text/uri-list";
 const char kMimeTypeMozillaURL[] = "text/x-moz-url";
-// Unstandardized format for downloading files  after drop events. Now only
-// works in Windows, but used to also work in Linux and MacOS.
-// See https://crbug.com/860557 and https://crbug.com/425170.
 const char kMimeTypeDownloadURL[] = "downloadurl";
 const char kMimeTypeHTML[] = "text/html";
 const char kMimeTypeRTF[] = "text/rtf";
 const char kMimeTypePNG[] = "image/png";
+
 #if !defined(OS_APPLE)
-// TODO(dcheng): This name is temporary. See crbug.com/106449.
 const char kMimeTypeWebCustomData[] = "chromium/x-web-custom-data";
 const char kMimeTypeWebkitSmartPaste[] = "chromium/x-webkit-paste";
 const char kMimeTypePepperCustomData[] = "chromium/x-pepper-custom-data";

ui/base/clipboard/clipboard_constants.h

@@ -24,6 +24,9 @@ namespace ui {
 COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES) extern const char kMimeTypeText[];
 COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES) extern const char kMimeTypeTextUtf8[];
 COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES) extern const char kMimeTypeURIList[];
+// Unstandardized format for downloading files  after drop events. Now only
+// works in Windows, but used to also work in Linux and MacOS.
+// See https://crbug.com/860557 and https://crbug.com/425170.
 COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES)
 extern const char kMimeTypeDownloadURL[];
 COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES)
@@ -31,7 +34,19 @@ extern const char kMimeTypeMozillaURL[];
 COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES) extern const char kMimeTypeHTML[];
 COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES) extern const char kMimeTypeRTF[];
 COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES) extern const char kMimeTypePNG[];
+
+// Linux-specific MIME type constants (also used in Fuchsia).
+#if defined(OS_LINUX) || defined(OS_FUCHSIA)
+COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES)
+constexpr char kMimeTypeLinuxUtf8String[] = "UTF8_STRING";
+COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES)
+constexpr char kMimeTypeLinuxString[] = "STRING";
+COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES)
+constexpr char kMimeTypeLinuxText[] = "TEXT";
+#endif  // defined(OS_LINUX) || defined(OS_FUCHSIA)
+
 #if !defined(OS_APPLE)
+// TODO(dcheng): This name is temporary. See crbug.com/106449.
 COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES)
 extern const char kMimeTypeWebCustomData[];
 COMPONENT_EXPORT(UI_BASE_CLIPBOARD_TYPES)

ui/base/clipboard/clipboard_ozone.cc

@@ -38,12 +38,6 @@ namespace ui {
 
 namespace {
 
-// TODO(crbug.com/1105892): those three constants can be found in a few other
-// places.  Perhaps it would be worth finding some common place for them?
-constexpr char kMimeTypeX11String[] = "STRING";
-constexpr char kMimeTypeX11Text[] = "TEXT";
-constexpr char kMimeTypeX11Utf8String[] = "UTF8_STRING";
-
 // The amount of time to wait for a request to complete before aborting it.
 constexpr base::TimeDelta kRequestTimeout = base::TimeDelta::FromSeconds(10);
 
@@ -564,8 +558,8 @@ void ClipboardOzone::WritePlatformRepresentations(
 void ClipboardOzone::WriteText(const char* text_data, size_t text_len) {
   std::vector<uint8_t> data(text_data, text_data + text_len);
   async_clipboard_ozone_->InsertData(
-      std::move(data), {kMimeTypeText, kMimeTypeX11Text, kMimeTypeX11String,
-                        kMimeTypeTextUtf8, kMimeTypeX11Utf8String});
+      std::move(data), {kMimeTypeText, kMimeTypeLinuxText, kMimeTypeLinuxString,
+                        kMimeTypeTextUtf8, kMimeTypeLinuxUtf8String});
 }
 
 void ClipboardOzone::WriteHTML(const char* markup_data,

ui/base/clipboard/clipboard_test_template.h

@@ -27,6 +27,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
+#include "build/chromecast_buildflags.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -167,6 +168,11 @@ TYPED_TEST(ClipboardTest, TextTest) {
 
   EXPECT_THAT(this->GetAvailableTypes(ClipboardBuffer::kCopyPaste),
               Contains(ASCIIToUTF16(kMimeTypeText)));
+#if defined(USE_OZONE) && !defined(OS_CHROMEOS) && !defined(OS_FUCHSIA) && \
+    !BUILDFLAG(IS_CHROMECAST)
+  EXPECT_THAT(this->GetAvailableTypes(ClipboardBuffer::kCopyPaste),
+              Contains(ASCIIToUTF16(kMimeTypeTextUtf8)));
+#endif
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
       ClipboardFormatType::GetPlainTextType(), ClipboardBuffer::kCopyPaste,
       /* data_dst = */ nullptr));
@@ -242,10 +248,13 @@ TYPED_TEST(ClipboardTest, RTFTest) {
 }
 #endif  // !defined(OS_ANDROID)
 
-// TODO(msisov, tonikitoo): Enable test once ClipboardOzone implements
-// selection support. https://crbug.com/911992
-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) && !defined(USE_OZONE)
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 TYPED_TEST(ClipboardTest, MultipleBufferTest) {
+#if defined(USE_OZONE)
+  if (!this->clipboard().IsSelectionBufferAvailable())
+    return;
+#endif
+
   base::string16 text(ASCIIToUTF16("Standard")), text_result;
   base::string16 markup(ASCIIToUTF16("<string>Selection</string>"));
   std::string url("http://www.example.com/"), url_result;

ui/base/clipboard/clipboard_x11.cc

@@ -758,9 +758,9 @@ void ClipboardX11::WriteText(const char* text_data, size_t text_len) {
       base::RefCountedString::TakeString(&str));
 
   x11_details_->InsertMapping(kMimeTypeText, mem);
-  x11_details_->InsertMapping(kText, mem);
-  x11_details_->InsertMapping(kString, mem);
-  x11_details_->InsertMapping(kUtf8String, mem);
+  x11_details_->InsertMapping(kMimeTypeLinuxText, mem);
+  x11_details_->InsertMapping(kMimeTypeLinuxString, mem);
+  x11_details_->InsertMapping(kMimeTypeLinuxUtf8String, mem);
 }
 
 void ClipboardX11::WriteHTML(const char* markup_data,

ui/base/x/selection_utils.cc

@@ -19,19 +19,13 @@
 
 namespace ui {
 
-const char kString[] = "STRING";
-const char kText[] = "TEXT";
-const char kTextPlain[] = "text/plain";
-const char kTextPlainUtf8[] = "text/plain;charset=utf-8";
-const char kUtf8String[] = "UTF8_STRING";
-
 std::vector<x11::Atom> GetTextAtomsFrom() {
   std::vector<x11::Atom> atoms;
-  atoms.push_back(gfx::GetAtom(kUtf8String));
-  atoms.push_back(gfx::GetAtom(kString));
-  atoms.push_back(gfx::GetAtom(kText));
-  atoms.push_back(gfx::GetAtom(kTextPlain));
-  atoms.push_back(gfx::GetAtom(kTextPlainUtf8));
+  atoms.push_back(gfx::GetAtom(kMimeTypeLinuxUtf8String));
+  atoms.push_back(gfx::GetAtom(kMimeTypeLinuxString));
+  atoms.push_back(gfx::GetAtom(kMimeTypeLinuxText));
+  atoms.push_back(gfx::GetAtom(kMimeTypeText));
+  atoms.push_back(gfx::GetAtom(kMimeTypeTextUtf8));
   return atoms;
 }
 
@@ -176,11 +170,12 @@ size_t SelectionData::GetSize() const {
 }
 
 std::string SelectionData::GetText() const {
-  if (type_ == gfx::GetAtom(kUtf8String) || type_ == gfx::GetAtom(kText) ||
-      type_ == gfx::GetAtom(kTextPlainUtf8)) {
+  if (type_ == gfx::GetAtom(kMimeTypeLinuxUtf8String) ||
+      type_ == gfx::GetAtom(kMimeTypeLinuxText) ||
+      type_ == gfx::GetAtom(kMimeTypeTextUtf8)) {
     return RefCountedMemoryToString(memory_);
-  } else if (type_ == gfx::GetAtom(kString) ||
-             type_ == gfx::GetAtom(kTextPlain)) {
+  } else if (type_ == gfx::GetAtom(kMimeTypeLinuxString) ||
+             type_ == gfx::GetAtom(kMimeTypeText)) {
     std::string result;
     base::ConvertToUtf8AndNormalize(RefCountedMemoryToString(memory_),
                                     base::kCodepageLatin1, &result);

ui/base/x/selection_utils.h

@@ -15,10 +15,6 @@
 namespace ui {
 class SelectionData;
 
-COMPONENT_EXPORT(UI_BASE_X) extern const char kString[];
-COMPONENT_EXPORT(UI_BASE_X) extern const char kText[];
-COMPONENT_EXPORT(UI_BASE_X) extern const char kUtf8String[];
-
 // Returns a list of all text atoms that we handle.
 COMPONENT_EXPORT(UI_BASE_X) std::vector<x11::Atom> GetTextAtomsFrom();
 

ui/base/x/x11_os_exchange_data_provider.cc

@@ -97,9 +97,9 @@ void XOSExchangeDataProvider::SetString(const base::string16& text_data) {
       base::RefCountedString::TakeString(&utf8));
 
   format_map_.Insert(gfx::GetAtom(kMimeTypeText), mem);
-  format_map_.Insert(gfx::GetAtom(kText), mem);
-  format_map_.Insert(gfx::GetAtom(kString), mem);
-  format_map_.Insert(gfx::GetAtom(kUtf8String), mem);
+  format_map_.Insert(gfx::GetAtom(kMimeTypeLinuxText), mem);
+  format_map_.Insert(gfx::GetAtom(kMimeTypeLinuxString), mem);
+  format_map_.Insert(gfx::GetAtom(kMimeTypeLinuxUtf8String), mem);
 }
 
 void XOSExchangeDataProvider::SetURL(const GURL& url,

ui/ozone/platform/wayland/host/wayland_data_offer_base.cc

@@ -9,14 +9,6 @@
 
 namespace ui {
 
-namespace {
-
-const char kString[] = "STRING";
-const char kText[] = "TEXT";
-const char kUtf8String[] = "UTF8_STRING";
-
-}  // namespace
-
 WaylandDataOfferBase::WaylandDataOfferBase() = default;
 WaylandDataOfferBase::~WaylandDataOfferBase() = default;
 
@@ -26,9 +18,10 @@ void WaylandDataOfferBase::EnsureTextMimeTypeIfNeeded() {
 
   if (std::any_of(mime_types_.begin(), mime_types_.end(),
                   [](const std::string& mime_type) {
-                    return mime_type == kString || mime_type == kText ||
+                    return mime_type == kMimeTypeLinuxString ||
+                           mime_type == kMimeTypeLinuxText ||
                            mime_type == kMimeTypeTextUtf8 ||
-                           mime_type == kUtf8String;
+                           mime_type == kMimeTypeLinuxUtf8String;
                   })) {
     mime_types_.push_back(kMimeTypeText);
     text_plain_mime_type_inserted_ = true;

ui/ozone/platform/x11/x11_clipboard_ozone.cc

@@ -25,23 +25,21 @@ namespace {
 
 const char kChromeSelection[] = "CHROME_SELECTION";
 const char kClipboard[] = "CLIPBOARD";
-const char kString[] = "STRING";
 const char kTargets[] = "TARGETS";
 const char kTimestamp[] = "TIMESTAMP";
-const char kUtf8String[] = "UTF8_STRING";
 
 // Helps to allow conversions for text/plain[;charset=utf-8] <=> [UTF8_]STRING.
 void ExpandTypes(std::vector<std::string>* list) {
   bool has_mime_type_text = Contains(*list, ui::kMimeTypeText);
-  bool has_string = Contains(*list, kString);
+  bool has_string = Contains(*list, kMimeTypeLinuxString);
   bool has_mime_type_utf8 = Contains(*list, kMimeTypeTextUtf8);
-  bool has_utf8_string = Contains(*list, kUtf8String);
+  bool has_utf8_string = Contains(*list, kMimeTypeLinuxUtf8String);
   if (has_mime_type_text && !has_string)
-    list->push_back(kString);
+    list->push_back(kMimeTypeLinuxString);
   if (has_string && !has_mime_type_text)
     list->push_back(ui::kMimeTypeText);
   if (has_mime_type_utf8 && !has_utf8_string)
-    list->push_back(kUtf8String);
+    list->push_back(kMimeTypeLinuxUtf8String);
   if (has_utf8_string && !has_mime_type_utf8)
     list->push_back(kMimeTypeTextUtf8);
 }
@@ -163,9 +161,11 @@ bool X11ClipboardOzone::OnSelectionRequest(
 
     std::string key = target_name;
     // Allow conversions for text/plain[;charset=utf-8] <=> [UTF8_]STRING.
-    if (key == kUtf8String && !Contains(offer_data_map, kUtf8String)) {
+    if (key == kMimeTypeLinuxUtf8String &&
+        !Contains(offer_data_map, kMimeTypeLinuxUtf8String)) {
       key = kMimeTypeTextUtf8;
-    } else if (key == kString && !Contains(offer_data_map, kString)) {
+    } else if (key == kMimeTypeLinuxString &&
+               !Contains(offer_data_map, kMimeTypeLinuxString)) {
       key = kMimeTypeText;
     }
     auto it = offer_data_map.find(key);
@@ -314,9 +314,9 @@ void X11ClipboardOzone::ReadRemoteClipboard(x11::Atom selection) {
   std::string target = selection_state.data_mime_type;
   if (!Contains(selection_state.mime_types, target)) {
     if (target == kMimeTypeText) {
-      target = kString;
+      target = kMimeTypeLinuxString;
     } else if (target == kMimeTypeTextUtf8) {
-      target = kUtf8String;
+      target = kMimeTypeLinuxUtf8String;
     }
   }