Add support for standard primary selection protocol extension

If primary-selection-unstable-v1 is available, it is used.
Otherwise, falls back to gtk-primary-selection.

Bug: 1088132
Change-Id: I9a17e4a4765ab7b5869948c67707f6af2173d001
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2440659Reviewed-by: Nick Yamane <nickdiego@igalia.com>
Reviewed-by: Maksim Sisov (GMT+3) <msisov@igalia.com>
Reviewed-by: Thomas Anderson <thomasanderson@chromium.org>
Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
Commit-Queue: Nick Yamane <nickdiego@igalia.com>
Cr-Commit-Position: refs/heads/master@{#813994}

AUTHORS

@@ -858,6 +858,7 @@ Robert Goldberg <goldberg@adobe.com>
 Robert Hogan <robhogan@gmail.com>
 Robert Nagy <robert.nagy@gmail.com>
 Robert Sesek <rsesek@bluestatic.org>
+Roger Zanoni <rogerzanoni@gmail.com>
 Roland Takacs <rtakacs.u-szeged@partner.samsung.com>
 Romain Pokrzywka <romain.pokrzywka@gmail.com>
 Rosen Dash <nqk836@motorola.com>

third_party/wayland-protocols/BUILD.gn

@@ -8,6 +8,11 @@ wayland_protocol("gtk_primary_selection_protocol") {
   sources = [ "unstable/gtk-primary-selection/gtk-primary-selection.xml" ]
 }
 
+wayland_protocol("primary_selection_protocol") {
+  sources =
+      [ "src/unstable/primary-selection/primary-selection-unstable-v1.xml" ]
+}
+
 wayland_protocol("input_method_protocol") {
   sources = [ "src/unstable/input-method/input-method-unstable-v1.xml" ]
 }

ui/ozone/platform/wayland/BUILD.gn

@@ -47,6 +47,12 @@ source_set("wayland") {
     "host/gtk_primary_selection_device_manager.h",
     "host/gtk_primary_selection_offer.cc",
     "host/gtk_primary_selection_offer.h",
+    "host/zwp_primary_selection_device.cc",
+    "host/zwp_primary_selection_device.h",
+    "host/zwp_primary_selection_device_manager.cc",
+    "host/zwp_primary_selection_device_manager.h",
+    "host/zwp_primary_selection_offer.cc",
+    "host/zwp_primary_selection_offer.h",
     "host/shell_object_factory.cc",
     "host/shell_object_factory.h",
     "host/shell_popup_wrapper.cc",
@@ -157,6 +163,7 @@ source_set("wayland") {
     "//third_party/wayland-protocols:linux_dmabuf_protocol",
     "//third_party/wayland-protocols:linux_explicit_synchronization_protocol",
     "//third_party/wayland-protocols:presentation_time_protocol",
+    "//third_party/wayland-protocols:primary_selection_protocol",
     "//third_party/wayland-protocols:text_input_protocol",
     "//third_party/wayland-protocols:viewporter_protocol",
     "//third_party/wayland-protocols:wayland_drm_protocol",

ui/ozone/platform/wayland/common/wayland_object.cc

@@ -10,6 +10,7 @@
 #include <linux-dmabuf-unstable-v1-client-protocol.h>
 #include <linux-explicit-synchronization-unstable-v1-client-protocol.h>
 #include <presentation-time-client-protocol.h>
+#include <primary-selection-unstable-v1-client-protocol.h>
 #include <text-input-unstable-v1-client-protocol.h>
 #include <viewporter-client-protocol.h>
 #include <wayland-drm-client-protocol.h>
@@ -92,6 +93,30 @@ const wl_interface* ObjectTraits<gtk_primary_selection_source>::interface =
 void (*ObjectTraits<gtk_primary_selection_source>::deleter)(
     gtk_primary_selection_source*) = &gtk_primary_selection_source_destroy;
 
+const wl_interface*
+    ObjectTraits<zwp_primary_selection_device_manager_v1>::interface =
+        &zwp_primary_selection_device_manager_v1_interface;
+void (*ObjectTraits<zwp_primary_selection_device_manager_v1>::deleter)(
+    zwp_primary_selection_device_manager_v1*) =
+    &zwp_primary_selection_device_manager_v1_destroy;
+
+const wl_interface* ObjectTraits<zwp_primary_selection_device_v1>::interface =
+    &zwp_primary_selection_device_v1_interface;
+void (*ObjectTraits<zwp_primary_selection_device_v1>::deleter)(
+    zwp_primary_selection_device_v1*) =
+    &zwp_primary_selection_device_v1_destroy;
+
+const wl_interface* ObjectTraits<zwp_primary_selection_offer_v1>::interface =
+    &zwp_primary_selection_offer_v1_interface;
+void (*ObjectTraits<zwp_primary_selection_offer_v1>::deleter)(
+    zwp_primary_selection_offer_v1*) = &zwp_primary_selection_offer_v1_destroy;
+
+const wl_interface* ObjectTraits<zwp_primary_selection_source_v1>::interface =
+    &zwp_primary_selection_source_v1_interface;
+void (*ObjectTraits<zwp_primary_selection_source_v1>::deleter)(
+    zwp_primary_selection_source_v1*) =
+    &zwp_primary_selection_source_v1_destroy;
+
 const wl_interface* ObjectTraits<wl_buffer>::interface = &wl_buffer_interface;
 void (*ObjectTraits<wl_buffer>::deleter)(wl_buffer*) = &wl_buffer_destroy;
 

ui/ozone/platform/wayland/common/wayland_object.h

@@ -13,6 +13,10 @@ struct gtk_primary_selection_device;
 struct gtk_primary_selection_device_manager;
 struct gtk_primary_selection_offer;
 struct gtk_primary_selection_source;
+struct zwp_primary_selection_device_v1;
+struct zwp_primary_selection_device_manager_v1;
+struct zwp_primary_selection_offer_v1;
+struct zwp_primary_selection_source_v1;
 struct wl_buffer;
 struct wl_callback;
 struct wl_compositor;
@@ -103,6 +107,30 @@ struct ObjectTraits<gtk_primary_selection_source> {
   static void (*deleter)(gtk_primary_selection_source*);
 };
 
+template <>
+struct ObjectTraits<zwp_primary_selection_device_manager_v1> {
+  static const wl_interface* interface;
+  static void (*deleter)(zwp_primary_selection_device_manager_v1*);
+};
+
+template <>
+struct ObjectTraits<zwp_primary_selection_device_v1> {
+  static const wl_interface* interface;
+  static void (*deleter)(zwp_primary_selection_device_v1*);
+};
+
+template <>
+struct ObjectTraits<zwp_primary_selection_offer_v1> {
+  static const wl_interface* interface;
+  static void (*deleter)(zwp_primary_selection_offer_v1*);
+};
+
+template <>
+struct ObjectTraits<zwp_primary_selection_source_v1> {
+  static const wl_interface* interface;
+  static void (*deleter)(zwp_primary_selection_source_v1*);
+};
+
 template <>
 struct ObjectTraits<wl_buffer> {
   static const wl_interface* interface;

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

@@ -43,7 +43,7 @@ void GtkPrimarySelectionDevice::OnDataOffer(
   DCHECK(self);
 
   self->connection()->clipboard()->UpdateSequenceNumber(
-      ClipboardBuffer::kCopyPaste);
+      ClipboardBuffer::kSelection);
 
   self->set_data_offer(std::make_unique<GtkPrimarySelectionOffer>(offer));
 }

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

@@ -6,12 +6,7 @@
 
 #include <gtk-primary-selection-client-protocol.h>
 
-#include <fcntl.h>
-#include <algorithm>
-
-#include "base/check.h"
 #include "base/files/file_util.h"
-#include "base/stl_util.h"
 #include "ui/base/clipboard/clipboard_constants.h"
 
 namespace ui {

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

@@ -14,6 +14,8 @@
 #include "ui/ozone/platform/wayland/common/wayland_object.h"
 #include "ui/ozone/platform/wayland/host/gtk_primary_selection_device.h"
 #include "ui/ozone/platform/wayland/host/gtk_primary_selection_device_manager.h"
+#include "ui/ozone/platform/wayland/host/zwp_primary_selection_device.h"
+#include "ui/ozone/platform/wayland/host/zwp_primary_selection_device_manager.h"
 #include "ui/ozone/platform/wayland/host/wayland_connection.h"
 #include "ui/ozone/platform/wayland/host/wayland_data_device.h"
 #include "ui/ozone/platform/wayland/host/wayland_data_device_manager.h"
@@ -185,7 +187,8 @@ void WaylandClipboard::GetAvailableMimeTypes(
 }
 
 bool WaylandClipboard::IsSelectionBufferAvailable() const {
-  return (connection_->primary_selection_device_manager() != nullptr);
+  return (connection_->zwp_primary_selection_device_manager() != nullptr) ||
+         (connection_->gtk_primary_selection_device_manager() != nullptr);
 }
 
 void WaylandClipboard::SetData(PlatformClipboard::Data contents,
@@ -214,7 +217,15 @@ wl::Clipboard* WaylandClipboard::GetClipboard(ClipboardBuffer buffer) {
     return copypaste_clipboard_.get();
 
   if (buffer == ClipboardBuffer::kSelection) {
-    if (auto* manager = connection_->primary_selection_device_manager()) {
+    if (auto* manager = connection_->zwp_primary_selection_device_manager()) {
+      if (!primary_selection_clipboard_) {
+        primary_selection_clipboard_ =
+            std::make_unique<wl::ClipboardImpl<ZwpPrimarySelectionDeviceManager>>(
+                manager);
+      }
+      return primary_selection_clipboard_.get();
+    } else if (auto* manager =
+                   connection_->gtk_primary_selection_device_manager()) {
       if (!primary_selection_clipboard_) {
         primary_selection_clipboard_ = std::make_unique<
             wl::ClipboardImpl<GtkPrimarySelectionDeviceManager>>(manager);

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

@@ -21,6 +21,7 @@
 #include "ui/gfx/geometry/point.h"
 #include "ui/ozone/platform/wayland/common/wayland_object.h"
 #include "ui/ozone/platform/wayland/host/gtk_primary_selection_device_manager.h"
+#include "ui/ozone/platform/wayland/host/zwp_primary_selection_device_manager.h"
 #include "ui/ozone/platform/wayland/host/wayland_buffer_manager_host.h"
 #include "ui/ozone/platform/wayland/host/wayland_clipboard.h"
 #include "ui/ozone/platform/wayland/host/wayland_cursor.h"
@@ -351,14 +352,23 @@ void WaylandConnection::Global(void* data,
         std::make_unique<WaylandDataDeviceManager>(
             data_device_manager.release(), connection);
     connection->CreateDataObjectsIfReady();
-  } else if (!connection->primary_selection_device_manager_ &&
+  } else if (!connection->gtk_primary_selection_device_manager_ &&
              strcmp(interface, "gtk_primary_selection_device_manager") == 0) {
-    wl::Object<gtk_primary_selection_device_manager> manager =
-        wl::Bind<gtk_primary_selection_device_manager>(
+    wl::Object<::gtk_primary_selection_device_manager> manager =
+        wl::Bind<::gtk_primary_selection_device_manager>(
             registry, name, kMaxGtkPrimarySelectionDeviceManagerVersion);
-    connection->primary_selection_device_manager_ =
+    connection->gtk_primary_selection_device_manager_ =
         std::make_unique<GtkPrimarySelectionDeviceManager>(manager.release(),
                                                            connection);
+  } else if (!connection->zwp_primary_selection_device_manager_ &&
+             strcmp(interface, "zwp_primary_selection_device_manager_v1") ==
+                 0) {
+    wl::Object<zwp_primary_selection_device_manager_v1> manager =
+        wl::Bind<zwp_primary_selection_device_manager_v1>(
+            registry, name, kMaxGtkPrimarySelectionDeviceManagerVersion);
+    connection->zwp_primary_selection_device_manager_ =
+        std::make_unique<ZwpPrimarySelectionDeviceManager>(manager.release(),
+                                                        connection);
   } else if (!connection->linux_explicit_synchronization_ &&
              (strcmp(interface, "zwp_linux_explicit_synchronization_v1") ==
               0)) {

ui/ozone/platform/wayland/host/wayland_connection.h

@@ -36,6 +36,7 @@ class WaylandDataDeviceManager;
 class WaylandCursorPosition;
 class WaylandWindowDragController;
 class GtkPrimarySelectionDeviceManager;
+class ZwpPrimarySelectionDeviceManager;
 class XdgForeignWrapper;
 
 class WaylandConnection {
@@ -130,8 +131,13 @@ class WaylandConnection {
     return data_device_manager_.get();
   }
 
-  GtkPrimarySelectionDeviceManager* primary_selection_device_manager() const {
-    return primary_selection_device_manager_.get();
+  GtkPrimarySelectionDeviceManager* gtk_primary_selection_device_manager()
+      const {
+    return gtk_primary_selection_device_manager_.get();
+  }
+
+  ZwpPrimarySelectionDeviceManager* zwp_primary_selection_device_manager() const {
+    return zwp_primary_selection_device_manager_.get();
   }
 
   WaylandDataDragController* data_drag_controller() const {
@@ -218,7 +224,10 @@ class WaylandConnection {
   std::unique_ptr<XdgForeignWrapper> xdg_foreign_;
 
   std::unique_ptr<GtkPrimarySelectionDeviceManager>
-      primary_selection_device_manager_;
+      gtk_primary_selection_device_manager_;
+
+  std::unique_ptr<ZwpPrimarySelectionDeviceManager>
+      zwp_primary_selection_device_manager_;
 
   std::unique_ptr<WaylandDataDragController> data_drag_controller_;
   std::unique_ptr<WaylandWindowDragController> window_drag_controller_;

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

@@ -5,6 +5,7 @@
 #include "ui/ozone/platform/wayland/host/wayland_data_source.h"
 
 #include <gtk-primary-selection-client-protocol.h>
+#include <primary-selection-unstable-v1-client-protocol.h>
 
 #include <cstdint>
 #include <vector>
@@ -145,6 +146,26 @@ void DataSource<gtk_primary_selection_source>::Offer(
   connection_->ScheduleFlush();
 }
 
+template <>
+void DataSource<zwp_primary_selection_source_v1>::Initialize() {
+  static const struct zwp_primary_selection_source_v1_listener
+      kDataSourceListener = {
+          DataSource<zwp_primary_selection_source_v1>::OnSend,
+          DataSource<zwp_primary_selection_source_v1>::OnCancel};
+  zwp_primary_selection_source_v1_add_listener(data_source_.get(),
+                                               &kDataSourceListener, this);
+}
+
+template <>
+void DataSource<zwp_primary_selection_source_v1>::Offer(
+    const std::vector<std::string>& mime_types) {
+  for (const auto& mime_type : mime_types)
+    zwp_primary_selection_source_v1_offer(data_source_.get(),
+                                          mime_type.c_str());
+  connection_->ScheduleFlush();
+}
+
 template class DataSource<gtk_primary_selection_source>;
+template class DataSource<zwp_primary_selection_source_v1>;
 
 }  // namespace wl

ui/ozone/platform/wayland/host/wayland_data_source.h

@@ -15,6 +15,7 @@
 
 struct wl_data_source;
 struct gtk_primary_selection_source;
+struct zwp_primary_selection_source_v1;
 
 namespace wl {
 template <typename T>
@@ -34,13 +35,13 @@ class WaylandConnection;
 // Implementation wise, these variants are share a single class template, with
 // specializations defined for each underlying supported extensions. Below are
 // the type aliases for the variants currently supported.
-//
-// TODO(crbug.com/1088132): Support standard primary selection extension.
 
 using WaylandDataSource = wl::DataSource<wl_data_source>;
 
 using GtkPrimarySelectionSource = wl::DataSource<gtk_primary_selection_source>;
 
+using ZwpPrimarySelectionSource = wl::DataSource<zwp_primary_selection_source_v1>;
+
 }  // namespace ui
 
 namespace wl {

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

+// Copyright 2020 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.
+
+#include "ui/ozone/platform/wayland/host/zwp_primary_selection_device.h"
+
+#include <primary-selection-unstable-v1-client-protocol.h>
+
+#include "ui/ozone/platform/wayland/host/zwp_primary_selection_offer.h"
+#include "ui/ozone/platform/wayland/host/wayland_connection.h"
+#include "ui/ozone/platform/wayland/host/wayland_data_source.h"
+
+namespace ui {
+
+// static
+ZwpPrimarySelectionDevice::ZwpPrimarySelectionDevice(
+    WaylandConnection* connection,
+    zwp_primary_selection_device_v1* data_device)
+    : WaylandDataDeviceBase(connection), data_device_(data_device) {
+  static const struct zwp_primary_selection_device_v1_listener kListener = {
+      ZwpPrimarySelectionDevice::OnDataOffer, ZwpPrimarySelectionDevice::OnSelection};
+  zwp_primary_selection_device_v1_add_listener(data_device_.get(), &kListener,
+                                               this);
+}
+
+ZwpPrimarySelectionDevice::~ZwpPrimarySelectionDevice() = default;
+
+void ZwpPrimarySelectionDevice::SetSelectionSource(
+    ZwpPrimarySelectionSource* source) {
+  DCHECK(source);
+  zwp_primary_selection_device_v1_set_selection(
+      data_device_.get(), source->data_source(), connection()->serial());
+  connection()->ScheduleFlush();
+}
+
+// static
+void ZwpPrimarySelectionDevice::OnDataOffer(
+    void* data,
+    zwp_primary_selection_device_v1* data_device,
+    zwp_primary_selection_offer_v1* offer) {
+  auto* self = static_cast<ZwpPrimarySelectionDevice*>(data);
+  DCHECK(self);
+
+  self->connection()->clipboard()->UpdateSequenceNumber(
+      ClipboardBuffer::kSelection);
+
+  self->set_data_offer(std::make_unique<ZwpPrimarySelectionOffer>(offer));
+}
+
+// static
+void ZwpPrimarySelectionDevice::OnSelection(
+    void* data,
+    zwp_primary_selection_device_v1* data_device,
+    zwp_primary_selection_offer_v1* offer) {
+  auto* self = static_cast<ZwpPrimarySelectionDevice*>(data);
+  DCHECK(self);
+
+  // 'offer' will be null to indicate that the selection is no longer valid,
+  // i.e. there is no longer clipboard data available to paste.
+  if (!offer) {
+    self->ResetDataOffer();
+
+    // Clear Clipboard cache.
+    self->connection()->clipboard()->SetData({}, {});
+    return;
+  }
+
+  DCHECK(self->data_offer());
+  self->data_offer()->EnsureTextMimeTypeIfNeeded();
+}
+
+}  // namespace ui

ui/ozone/platform/wayland/host/zwp_primary_selection_device.h

+// Copyright 2020 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.
+
+#ifndef UI_OZONE_PLATFORM_WAYLAND_HOST_PRIMARY_SELECTION_DEVICE_H_
+#define UI_OZONE_PLATFORM_WAYLAND_HOST_PRIMARY_SELECTION_DEVICE_H_
+
+#include "ui/ozone/platform/wayland/common/wayland_object.h"
+#include "ui/ozone/platform/wayland/host/wayland_data_device_base.h"
+#include "ui/ozone/platform/wayland/host/wayland_data_source.h"
+
+struct zwp_primary_selection_device_v1;
+
+namespace ui {
+
+class WaylandConnection;
+
+// This class provides access to primary selection clipboard
+class ZwpPrimarySelectionDevice : public WaylandDataDeviceBase {
+ public:
+  ZwpPrimarySelectionDevice(WaylandConnection* connection,
+                         zwp_primary_selection_device_v1* data_device);
+
+  ZwpPrimarySelectionDevice(const ZwpPrimarySelectionDevice&) = delete;
+  ZwpPrimarySelectionDevice& operator =(const ZwpPrimarySelectionDevice&) = delete;
+
+  ~ZwpPrimarySelectionDevice() override;
+
+  zwp_primary_selection_device_v1* data_device() const {
+    return data_device_.get();
+  }
+
+  void SetSelectionSource(ZwpPrimarySelectionSource* source);
+
+ private:
+  // primary_selection_device_listener callbacks
+  static void OnDataOffer(void* data,
+                          zwp_primary_selection_device_v1* data_device,
+                          zwp_primary_selection_offer_v1* offer);
+  static void OnSelection(void* data,
+                          zwp_primary_selection_device_v1* data_device,
+                          zwp_primary_selection_offer_v1* offer);
+
+  // The Wayland object wrapped by this instance.
+  wl::Object<zwp_primary_selection_device_v1> data_device_;
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_PLATFORM_WAYLAND_HOST_PRIMARY_SELECTION_DEVICE_H_

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

+// Copyright 2020 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.
+
+#include "ui/ozone/platform/wayland/host/zwp_primary_selection_device_manager.h"
+
+#include <primary-selection-unstable-v1-client-protocol.h>
+
+#include <memory>
+
+#include "ui/ozone/platform/wayland/host/zwp_primary_selection_device.h"
+#include "ui/ozone/platform/wayland/host/wayland_connection.h"
+#include "ui/ozone/platform/wayland/host/wayland_data_source.h"
+
+namespace ui {
+
+ZwpPrimarySelectionDeviceManager::ZwpPrimarySelectionDeviceManager(
+    zwp_primary_selection_device_manager_v1* manager,
+    WaylandConnection* connection)
+    : device_manager_(manager), connection_(connection) {
+  DCHECK(connection_);
+  DCHECK(device_manager_);
+}
+
+ZwpPrimarySelectionDeviceManager::~ZwpPrimarySelectionDeviceManager() = default;
+
+ZwpPrimarySelectionDevice* ZwpPrimarySelectionDeviceManager::GetDevice() {
+  DCHECK(connection_->seat());
+  if (!device_) {
+    device_ = std::make_unique<ZwpPrimarySelectionDevice>(
+        connection_, zwp_primary_selection_device_manager_v1_get_device(
+                         device_manager_.get(), connection_->seat()));
+  }
+  DCHECK(device_);
+  return device_.get();
+}
+
+std::unique_ptr<ZwpPrimarySelectionSource>
+ZwpPrimarySelectionDeviceManager::CreateSource(
+    ZwpPrimarySelectionSource::Delegate* delegate) {
+  auto* data_source = zwp_primary_selection_device_manager_v1_create_source(
+      device_manager_.get());
+  return std::make_unique<ZwpPrimarySelectionSource>(data_source, connection_,
+                                                  delegate);
+}
+
+}  // namespace ui

ui/ozone/platform/wayland/host/zwp_primary_selection_device_manager.h

+// Copyright 2020 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.
+
+#ifndef UI_OZONE_PLATFORM_WAYLAND_HOST_PRIMARY_SELECTION_DEVICE_MANAGER_H_
+#define UI_OZONE_PLATFORM_WAYLAND_HOST_PRIMARY_SELECTION_DEVICE_MANAGER_H_
+
+#include <memory>
+
+#include "ui/ozone/platform/wayland/common/wayland_object.h"
+#include "ui/ozone/platform/wayland/host/wayland_data_source.h"
+
+namespace ui {
+
+class ZwpPrimarySelectionDevice;
+class WaylandConnection;
+
+class ZwpPrimarySelectionDeviceManager {
+ public:
+  using DataSource = ZwpPrimarySelectionSource;
+  using DataDevice = ZwpPrimarySelectionDevice;
+
+  ZwpPrimarySelectionDeviceManager(
+      zwp_primary_selection_device_manager_v1* manager,
+      WaylandConnection* connection);
+  ZwpPrimarySelectionDeviceManager(const ZwpPrimarySelectionDeviceManager&) = delete;
+  ZwpPrimarySelectionDeviceManager& operator=(
+      const ZwpPrimarySelectionDeviceManager&) = delete;
+  ~ZwpPrimarySelectionDeviceManager();
+
+  ZwpPrimarySelectionDevice* GetDevice();
+  std::unique_ptr<ZwpPrimarySelectionSource> CreateSource(
+      ZwpPrimarySelectionSource::Delegate* delegate);
+
+ private:
+  wl::Object<zwp_primary_selection_device_manager_v1> device_manager_;
+
+  WaylandConnection* const connection_;
+
+  std::unique_ptr<ZwpPrimarySelectionDevice> device_;
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_PLATFORM_WAYLAND_HOST_PRIMARY_SELECTION_DEVICE_MANAGER_H_

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

+// Copyright 2020 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.
+
+#include "ui/ozone/platform/wayland/host/zwp_primary_selection_offer.h"
+
+#include <primary-selection-unstable-v1-client-protocol.h>
+
+#include <fcntl.h>
+#include <algorithm>
+
+#include "base/check.h"
+#include "base/files/file_util.h"
+#include "base/stl_util.h"
+#include "ui/base/clipboard/clipboard_constants.h"
+
+namespace ui {
+
+ZwpPrimarySelectionOffer::ZwpPrimarySelectionOffer(
+    zwp_primary_selection_offer_v1* data_offer)
+    : data_offer_(data_offer) {
+  static const struct zwp_primary_selection_offer_v1_listener kListener = {
+      ZwpPrimarySelectionOffer::OnOffer};
+  zwp_primary_selection_offer_v1_add_listener(data_offer, &kListener, this);
+}
+
+ZwpPrimarySelectionOffer::~ZwpPrimarySelectionOffer() {
+  data_offer_.reset();
+}
+
+base::ScopedFD ZwpPrimarySelectionOffer::Receive(const std::string& mime_type) {
+  if (!base::Contains(mime_types(), mime_type))
+    return base::ScopedFD();
+
+  base::ScopedFD read_fd;
+  base::ScopedFD write_fd;
+  PCHECK(base::CreatePipe(&read_fd, &write_fd));
+
+  // If we needed to forcibly write "text/plain" as an available
+  // mimetype, then it is safer to "read" the clipboard data with
+  // a mimetype mime_type known to be available.
+  std::string effective_mime_type = mime_type;
+  if (mime_type == kMimeTypeText && text_plain_mime_type_inserted())
+    effective_mime_type = kMimeTypeTextUtf8;
+
+  zwp_primary_selection_offer_v1_receive(
+      data_offer_.get(), effective_mime_type.data(), write_fd.get());
+  return read_fd;
+}
+
+// static
+void ZwpPrimarySelectionOffer::OnOffer(void* data,
+                                    zwp_primary_selection_offer_v1* data_offer,
+                                    const char* mime_type) {
+  auto* self = static_cast<ZwpPrimarySelectionOffer*>(data);
+  self->AddMimeType(mime_type);
+}
+
+}  // namespace ui

ui/ozone/platform/wayland/host/zwp_primary_selection_offer.h

+// Copyright 2020 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.
+
+#ifndef UI_OZONE_PLATFORM_WAYLAND_HOST_PRIMARY_SELECTION_OFFER_H_
+#define UI_OZONE_PLATFORM_WAYLAND_HOST_PRIMARY_SELECTION_OFFER_H_
+
+#include <string>
+
+#include "base/files/scoped_file.h"
+#include "base/macros.h"
+#include "ui/ozone/platform/wayland/common/wayland_object.h"
+#include "ui/ozone/platform/wayland/host/wayland_data_offer_base.h"
+
+struct zwp_primary_selection_offer_v1;
+
+namespace ui {
+
+// This class represents a piece of data offered for transfer by another client,
+// the source client (see ZwpPrimarySelectionSource for more). It is used by the
+// primary selection mechanism.
+//
+// The offer describes MIME types that the data can be converted to and provides
+// the mechanism for transferring the data directly from the source client.
+class ZwpPrimarySelectionOffer : public WaylandDataOfferBase {
+ public:
+  // Takes ownership of data_offer.
+  explicit ZwpPrimarySelectionOffer(zwp_primary_selection_offer_v1* data_offer);
+
+  ZwpPrimarySelectionOffer(const ZwpPrimarySelectionOffer &) = delete;
+  ZwpPrimarySelectionOffer &operator =(const ZwpPrimarySelectionOffer &) = delete;
+
+  ~ZwpPrimarySelectionOffer() override;
+
+  // WaylandDataOfferBase overrides:
+  base::ScopedFD Receive(const std::string& mime_type) override;
+
+ private:
+  // primary_selection_offer_listener callbacks.
+  static void OnOffer(void* data,
+                      zwp_primary_selection_offer_v1* data_offer,
+                      const char* mime_type);
+
+  // The Wayland object wrapped by this instance.
+  wl::Object<zwp_primary_selection_offer_v1> data_offer_;
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_PLATFORM_WAYLAND_HOST_PRIMARY_SELECTION_OFFER_H_