Reland "ozone/wayland: Fix data objects initialization and ownership"

This is a reland of 5930a9fd

Original change's description:
> ozone/wayland: Fix data objects initialization and ownership
> 
> DataDevice-related wrappers initialization and ownership, for both
> standard and GTK's primary selection, are quite confusing and spread
> over different parts of the backend code. This CL fixes and simplifies
> it by:
> 
> - Moving {WaylandData,GtkPrimarySelection}Device ownership to their
> respective DataManager wrapper class. E.g: WaylandDataDeviceManager owns
> WaylandDataDevice singleton;
> 
> - Fix WaylandClipboard initialization whether the compositor happens to
> advertise GtkPrimarySelectionDeviceManager after wl_seat and
> wl_data_device_manager;
> 
> - Use dependency injection to provide DataSources with the correct
> DataDevice instance at their construction time;
> 
> - Clean up WaylandConnection by getting rid of the multiple (and almost
> unused) data device getters from it as well as removing unneeded header
> includes.
> 
> Bug: 896640
> Change-Id: Ie12964fdf4e7b78bbbd9a11e133ab082613f1c7b
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2216320
> Reviewed-by: Maksim Sisov <msisov@igalia.com>
> Commit-Queue: Nick Yamane <nickdiego@igalia.com>
> Cr-Commit-Position: refs/heads/master@{#773235}

Bug: 896640
Change-Id: I52ec359c5339847674ab0ab8f89a96c15ededf59
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2225502
Auto-Submit: Nick Yamane <nickdiego@igalia.com>
Commit-Queue: Maksim Sisov <msisov@igalia.com>
Reviewed-by: Maksim Sisov <msisov@igalia.com>
Cr-Commit-Position: refs/heads/master@{#774031}

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

@@ -6,6 +6,9 @@
 
 #include <gtk-primary-selection-client-protocol.h>
 
+#include <memory>
+
+#include "ui/ozone/platform/wayland/host/gtk_primary_selection_device.h"
 #include "ui/ozone/platform/wayland/host/gtk_primary_selection_source.h"
 #include "ui/ozone/platform/wayland/host/wayland_connection.h"
 
@@ -14,24 +17,28 @@ namespace ui {
 GtkPrimarySelectionDeviceManager::GtkPrimarySelectionDeviceManager(
     gtk_primary_selection_device_manager* manager,
     WaylandConnection* connection)
-    : gtk_primary_selection_device_manager_(manager), connection_(connection) {
+    : device_manager_(manager), connection_(connection) {
   DCHECK(connection_);
-  DCHECK(gtk_primary_selection_device_manager_);
+  DCHECK(device_manager_);
 }
 
 GtkPrimarySelectionDeviceManager::~GtkPrimarySelectionDeviceManager() = default;
 
-gtk_primary_selection_device* GtkPrimarySelectionDeviceManager::GetDevice() {
+GtkPrimarySelectionDevice* GtkPrimarySelectionDeviceManager::GetDevice() {
   DCHECK(connection_->seat());
-  return gtk_primary_selection_device_manager_get_device(
-      gtk_primary_selection_device_manager_.get(), connection_->seat());
+  if (!device_) {
+    device_ = std::make_unique<GtkPrimarySelectionDevice>(
+        connection_, gtk_primary_selection_device_manager_get_device(
+                         device_manager_.get(), connection_->seat()));
+  }
+  DCHECK(device_);
+  return device_.get();
 }
 
 std::unique_ptr<GtkPrimarySelectionSource>
 GtkPrimarySelectionDeviceManager::CreateSource() {
-  gtk_primary_selection_source* data_source =
-      gtk_primary_selection_device_manager_create_source(
-          gtk_primary_selection_device_manager_.get());
+  auto* data_source =
+      gtk_primary_selection_device_manager_create_source(device_manager_.get());
   return std::make_unique<GtkPrimarySelectionSource>(data_source, connection_);
 }
 

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

@@ -11,10 +11,10 @@
 #include "ui/ozone/platform/wayland/common/wayland_object.h"
 
 struct gtk_primary_selection_device_manager;
-struct gtk_primary_selection_device;
 
 namespace ui {
 
+class GtkPrimarySelectionDevice;
 class GtkPrimarySelectionSource;
 class WaylandConnection;
 
@@ -25,14 +25,15 @@ class GtkPrimarySelectionDeviceManager {
       WaylandConnection* connection);
   ~GtkPrimarySelectionDeviceManager();
 
-  gtk_primary_selection_device* GetDevice();
+  GtkPrimarySelectionDevice* GetDevice();
   std::unique_ptr<GtkPrimarySelectionSource> CreateSource();
 
  private:
-  wl::Object<gtk_primary_selection_device_manager>
-      gtk_primary_selection_device_manager_;
+  wl::Object<gtk_primary_selection_device_manager> device_manager_;
 
-  WaylandConnection* connection_;
+  WaylandConnection* const connection_;
+
+  std::unique_ptr<GtkPrimarySelectionDevice> device_;
 
   DISALLOW_COPY_AND_ASSIGN(GtkPrimarySelectionDeviceManager);
 };

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

@@ -6,9 +6,14 @@
 
 #include <gtk-primary-selection-client-protocol.h>
 
+#include <string>
+#include <vector>
+
 #include "base/check.h"
 #include "base/files/file_util.h"
 #include "ui/base/clipboard/clipboard_constants.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/wayland_connection.h"
 
 namespace ui {
@@ -17,9 +22,8 @@ GtkPrimarySelectionSource::GtkPrimarySelectionSource(
     gtk_primary_selection_source* data_source,
     WaylandConnection* connection)
     : data_source_(data_source), connection_(connection) {
-  DCHECK(connection_);
   DCHECK(data_source_);
-
+  DCHECK(connection_);
   static const struct gtk_primary_selection_source_listener
       kDataSourceListener = {GtkPrimarySelectionSource::OnSend,
                              GtkPrimarySelectionSource::OnCancelled};
@@ -66,10 +70,9 @@ void GtkPrimarySelectionSource::WriteToClipboard(
       gtk_primary_selection_source_offer(data_source_.get(), kMimeTypeTextUtf8);
   }
 
+  auto* device = connection_->primary_selection_device_manager()->GetDevice();
   gtk_primary_selection_device_set_selection(
-      connection_->primary_selection_device(), data_source_.get(),
-      connection_->serial());
-
+      device->data_device(), data_source_.get(), connection_->serial());
   connection_->ScheduleFlush();
 }
 

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

@@ -18,7 +18,7 @@ class WaylandConnection;
 
 class GtkPrimarySelectionSource : public WaylandDataSourceBase {
  public:
-  // Takes ownership of data_source.
+  // Takes ownership of |data_source|.
   GtkPrimarySelectionSource(gtk_primary_selection_source* data_source,
                             WaylandConnection* connection);
   ~GtkPrimarySelectionSource() override;
@@ -36,7 +36,7 @@ class GtkPrimarySelectionSource : public WaylandDataSourceBase {
   // The gtk_primary_selection_source wrapped by this instance.
   wl::Object<gtk_primary_selection_source> data_source_;
 
-  WaylandConnection* connection_ = nullptr;
+  WaylandConnection* const connection_;
 
   DISALLOW_COPY_AND_ASSIGN(GtkPrimarySelectionSource);
 };

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

@@ -6,26 +6,26 @@
 
 #include <string>
 
+#include "base/notreached.h"
+#include "ui/base/clipboard/clipboard_buffer.h"
+#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/gtk_primary_selection_source.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_base.h"
 #include "ui/ozone/platform/wayland/host/wayland_data_device_manager.h"
 #include "ui/ozone/platform/wayland/host/wayland_data_source_base.h"
 
 namespace ui {
 
 WaylandClipboard::WaylandClipboard(
-    WaylandDataDeviceManager* data_device_manager,
-    WaylandDataDevice* data_device,
-    GtkPrimarySelectionDeviceManager* primary_selection_device_manager,
-    GtkPrimarySelectionDevice* primary_selection_device)
-    : data_device_manager_(data_device_manager),
-      data_device_(data_device),
-      primary_selection_device_manager_(primary_selection_device_manager),
-      primary_selection_device_(primary_selection_device) {
+    WaylandConnection* connection,
+    WaylandDataDeviceManager* data_device_manager)
+    : connection_(connection), data_device_manager_(data_device_manager) {
+  DCHECK(connection_);
   DCHECK(data_device_manager_);
-  DCHECK(data_device_);
 }
 
 WaylandClipboard::~WaylandClipboard() = default;
@@ -34,25 +34,10 @@ void WaylandClipboard::OfferClipboardData(
     ClipboardBuffer buffer,
     const PlatformClipboard::DataMap& data_map,
     PlatformClipboard::OfferDataClosure callback) {
-  WaylandDataSourceBase* data_source = nullptr;
-  if (buffer == ClipboardBuffer::kCopyPaste) {
-    if (!clipboard_data_source_)
-      clipboard_data_source_ = data_device_manager_->CreateSource();
-    data_source = clipboard_data_source_.get();
-  } else {
-    if (!IsPrimarySelectionSupported()) {
-      std::move(callback).Run();
-      return;
-    }
-    if (!primary_data_source_)
-      primary_data_source_ = primary_selection_device_manager_->CreateSource();
-    data_source = primary_data_source_.get();
+  if (auto* data_source = GetDataSource(buffer)) {
+    data_source->WriteToClipboard(data_map);
+    data_source->set_data_map(data_map);
   }
-
-  DCHECK(data_source);
-  data_source->WriteToClipboard(data_map);
-  data_source->set_data_map(data_map);
-
   std::move(callback).Run();
 }
 
@@ -64,15 +49,9 @@ void WaylandClipboard::RequestClipboardData(
   read_clipboard_closure_ = std::move(callback);
   DCHECK(data_map);
   data_map_ = data_map;
-  if (buffer == ClipboardBuffer::kCopyPaste) {
-    if (!data_device_->RequestSelectionData(mime_type))
-      SetData({}, mime_type);
-  } else {
-    if (!IsPrimarySelectionSupported() ||
-        !primary_selection_device_->RequestSelectionData(mime_type)) {
-      SetData({}, mime_type);
-    }
-  }
+  auto* device = GetDataDevice(buffer);
+  if (!device || !device->RequestSelectionData(mime_type))
+    SetData({}, mime_type);
 }
 
 bool WaylandClipboard::IsSelectionOwner(ClipboardBuffer buffer) {
@@ -92,14 +71,9 @@ void WaylandClipboard::SetSequenceNumberUpdateCb(
 void WaylandClipboard::GetAvailableMimeTypes(
     ClipboardBuffer buffer,
     PlatformClipboard::GetMimeTypesClosure callback) {
-  if (buffer == ClipboardBuffer::kCopyPaste) {
-    std::move(callback).Run(data_device_->GetAvailableMimeTypes());
-  } else {
-    std::move(callback).Run(
-        IsPrimarySelectionSupported()
-            ? primary_selection_device_->GetAvailableMimeTypes()
-            : std::vector<std::string>{});
-  }
+  auto* device = GetDataDevice(buffer);
+  std::move(callback).Run(!device ? device->GetAvailableMimeTypes()
+                                  : std::vector<std::string>{});
 }
 
 void WaylandClipboard::DataSourceCancelled(ClipboardBuffer buffer) {
@@ -135,7 +109,50 @@ void WaylandClipboard::UpdateSequenceNumber(ClipboardBuffer buffer) {
 }
 
 bool WaylandClipboard::IsPrimarySelectionSupported() const {
-  return primary_selection_device_manager_ && primary_selection_device_;
+  return !!GetDataDevice(ClipboardBuffer::kSelection);
+}
+
+WaylandDataDeviceBase* WaylandClipboard::GetDataDevice(
+    ClipboardBuffer buffer) const {
+  switch (buffer) {
+    case ClipboardBuffer::kCopyPaste: {
+      return connection_->data_device_manager()->GetDevice();
+    }
+    case ClipboardBuffer::kSelection: {
+      return connection_->primary_selection_device_manager()
+                 ? connection_->primary_selection_device_manager()->GetDevice()
+                 : nullptr;
+    }
+    default: {
+      NOTREACHED();
+      return nullptr;
+    }
+  }
+}
+
+WaylandDataSourceBase* WaylandClipboard::GetDataSource(ClipboardBuffer buffer) {
+  switch (buffer) {
+    case ClipboardBuffer::kCopyPaste: {
+      if (!clipboard_data_source_) {
+        clipboard_data_source_ =
+            connection_->data_device_manager()->CreateSource();
+      }
+      return clipboard_data_source_.get();
+    }
+    case ClipboardBuffer::kSelection: {
+      if (!IsPrimarySelectionSupported())
+        return nullptr;
+      if (!primary_data_source_) {
+        primary_data_source_ =
+            connection_->primary_selection_device_manager()->CreateSource();
+      }
+      return primary_data_source_.get();
+    }
+    default: {
+      NOTREACHED();
+      return nullptr;
+    }
+  }
 }
 
 }  // namespace ui

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

@@ -10,28 +10,25 @@
 
 #include "base/callback.h"
 #include "base/macros.h"
-#include "ui/ozone/platform/wayland/host/wayland_data_source.h"
 #include "ui/ozone/public/platform_clipboard.h"
 
 namespace ui {
 
-class GtkPrimarySelectionDevice;
-class GtkPrimarySelectionDeviceManager;
 class GtkPrimarySelectionSource;
-class WaylandDataDevice;
+class WaylandConnection;
+class WaylandDataDeviceBase;
 class WaylandDataDeviceManager;
+class WaylandDataSourceBase;
+class WaylandDataSource;
 
 // Handles clipboard operations.
 //
-// Owned by WaylandConnection, which provides a data device and a data device
-// manager.
+// WaylandConnection's wl_data_device_manager wrapper object is required to be
+// non-null for objects of this class so it can provide basic functionality.
 class WaylandClipboard : public PlatformClipboard {
  public:
-  WaylandClipboard(
-      WaylandDataDeviceManager* data_device_manager,
-      WaylandDataDevice* data_device,
-      GtkPrimarySelectionDeviceManager* primary_selection_device_manager,
-      GtkPrimarySelectionDevice* primary_selection_device);
+  WaylandClipboard(WaylandConnection* connection,
+                   WaylandDataDeviceManager* data_device_manager);
   ~WaylandClipboard() override;
 
   // PlatformClipboard.
@@ -58,13 +55,23 @@ class WaylandClipboard : public PlatformClipboard {
 
  private:
   bool IsPrimarySelectionSupported() const;
+  WaylandDataDeviceBase* GetDataDevice(ClipboardBuffer buffer) const;
+  WaylandDataSourceBase* GetDataSource(ClipboardBuffer buffer);
+
+  // WaylandConnection providing optional data device managers, e.g: gtk
+  // primary selection.
+  WaylandConnection* const connection_;
+
+  // Owned by WaylandConnection and required to be non-null so that
+  // WaylandConnection can be of some usefulness.
+  WaylandDataDeviceManager* const data_device_manager_;
 
   // Holds a temporary instance of the client's clipboard content
   // so that we can asynchronously write to it.
   PlatformClipboard::DataMap* data_map_ = nullptr;
 
-  // Notifies whenever clipboard sequence number is changed. Can be empty if not
-  // set.
+  // Notifies whenever clipboard sequence number is changed. Can be empty if
+  // not set.
   PlatformClipboard::SequenceNumberUpdateCb update_sequence_cb_;
 
   // Stores the callback to be invoked upon data reading from clipboard.
@@ -73,12 +80,6 @@ class WaylandClipboard : public PlatformClipboard {
   std::unique_ptr<WaylandDataSource> clipboard_data_source_;
   std::unique_ptr<GtkPrimarySelectionSource> primary_data_source_;
 
-  // These four instances are owned by the connection.
-  WaylandDataDeviceManager* const data_device_manager_;
-  WaylandDataDevice* const data_device_;
-  GtkPrimarySelectionDeviceManager* const primary_selection_device_manager_;
-  GtkPrimarySelectionDevice* const primary_selection_device_;
-
   DISALLOW_COPY_AND_ASSIGN(WaylandClipboard);
 };
 

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

@@ -9,7 +9,7 @@
 
 #include <algorithm>
 #include <memory>
-#include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ -17,12 +17,15 @@
 #include "base/message_loop/message_loop_current.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "mojo/public/cpp/system/platform_handle.h"
 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
-#include "ui/gfx/swap_result.h"
+#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/wayland_buffer_manager_host.h"
+#include "ui/ozone/platform/wayland/host/wayland_clipboard.h"
 #include "ui/ozone/platform/wayland/host/wayland_cursor.h"
+#include "ui/ozone/platform/wayland/host/wayland_cursor_position.h"
+#include "ui/ozone/platform/wayland/host/wayland_data_device_manager.h"
 #include "ui/ozone/platform/wayland/host/wayland_data_drag_controller.h"
 #include "ui/ozone/platform/wayland/host/wayland_drm.h"
 #include "ui/ozone/platform/wayland/host/wayland_event_source.h"
@@ -130,7 +133,7 @@ void WaylandConnection::SetCursorBitmap(const std::vector<SkBitmap>& bitmaps,
 }
 
 bool WaylandConnection::IsDragInProgress() const {
-  // |data_device_| can be null when running on headless weston.
+  // |data_drag_controller_| can be null when running on headless weston.
   return data_drag_controller_ && data_drag_controller_->state() !=
                                       WaylandDataDragController::State::kIdle;
 }
@@ -180,22 +183,16 @@ void WaylandConnection::UpdateInputDevices(wl_seat* seat,
   }
 }
 
-void WaylandConnection::EnsureDataDevice() {
-  if (!data_device_manager_ || !seat_)
-    return;
-  DCHECK(!data_device_);
-  wl_data_device* data_device = data_device_manager_->GetDevice();
-  data_device_ = std::make_unique<WaylandDataDevice>(this, data_device);
-  data_drag_controller_ = std::make_unique<WaylandDataDragController>(this);
-
-  if (primary_selection_device_manager_) {
-    primary_selection_device_ = std::make_unique<GtkPrimarySelectionDevice>(
-        this, primary_selection_device_manager_->GetDevice());
-  }
+void WaylandConnection::CreateDataObjectsIfReady() {
+  if (data_device_manager_ && seat_) {
+    DCHECK(!data_drag_controller_);
+    data_drag_controller_ = std::make_unique<WaylandDataDragController>(
+        this, data_device_manager_.get());
 
-  clipboard_ = std::make_unique<WaylandClipboard>(
-      data_device_manager_.get(), data_device_.get(),
-      primary_selection_device_manager_.get(), primary_selection_device_.get());
+    DCHECK(!clipboard_);
+    clipboard_ =
+        std::make_unique<WaylandClipboard>(this, data_device_manager_.get());
+  }
 }
 
 // static
@@ -241,7 +238,7 @@ void WaylandConnection::Global(void* data,
       return;
     }
     wl_seat_add_listener(connection->seat_.get(), &seat_listener, connection);
-    connection->EnsureDataDevice();
+    connection->CreateDataObjectsIfReady();
   } else if (!connection->shell_v6_ &&
              strcmp(interface, "zxdg_shell_v6") == 0) {
     // Check for zxdg_shell_v6 first.
@@ -296,7 +293,7 @@ void WaylandConnection::Global(void* data,
     connection->data_device_manager_ =
         std::make_unique<WaylandDataDeviceManager>(
             data_device_manager.release(), connection);
-    connection->EnsureDataDevice();
+    connection->CreateDataObjectsIfReady();
   } else if (!connection->primary_selection_device_manager_ &&
              strcmp(interface, "gtk_primary_selection_device_manager") == 0) {
     wl::Object<gtk_primary_selection_device_manager> manager =

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

@@ -6,22 +6,19 @@
 #define UI_OZONE_PLATFORM_WAYLAND_HOST_WAYLAND_CONNECTION_H_
 
 #include <memory>
-#include <string>
 #include <vector>
 
-#include "ui/gfx/buffer_types.h"
-#include "ui/gfx/native_widget_types.h"
+#include "third_party/skia/include/core/SkBitmap.h"
 #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/wayland_clipboard.h"
-#include "ui/ozone/platform/wayland/host/wayland_cursor_position.h"
-#include "ui/ozone/platform/wayland/host/wayland_data_device.h"
-#include "ui/ozone/platform/wayland/host/wayland_data_device_manager.h"
 #include "ui/ozone/platform/wayland/host/wayland_data_drag_controller.h"
 #include "ui/ozone/platform/wayland/host/wayland_data_source.h"
 #include "ui/ozone/platform/wayland/host/wayland_window_manager.h"
 
+namespace gfx {
+class Point;
+}
+
 namespace ui {
 
 class WaylandBufferManagerHost;
@@ -34,6 +31,9 @@ class WaylandPointer;
 class WaylandShm;
 class WaylandTouch;
 class WaylandZwpLinuxDmabuf;
+class WaylandDataDeviceManager;
+class WaylandCursorPosition;
+class GtkPrimarySelectionDeviceManager;
 
 class WaylandConnection {
  public:
@@ -54,10 +54,6 @@ class WaylandConnection {
   xdg_wm_base* shell() const { return shell_.get(); }
   zxdg_shell_v6* shell_v6() const { return shell_v6_.get(); }
   wl_seat* seat() const { return seat_.get(); }
-  wl_data_device* data_device() const { return data_device_->data_device(); }
-  gtk_primary_selection_device* primary_selection_device() const {
-    return primary_selection_device_->data_device();
-  }
   wp_presentation* presentation() const { return presentation_.get(); }
   zwp_text_input_manager_v1* text_input_manager_v1() const {
     return text_input_manager_v1_.get();
@@ -105,12 +101,14 @@ class WaylandConnection {
     return &wayland_window_manager_;
   }
 
-  WaylandDataDevice* wayland_data_device() const { return data_device_.get(); }
-
   WaylandDataDeviceManager* data_device_manager() const {
     return data_device_manager_.get();
   }
 
+  GtkPrimarySelectionDeviceManager* primary_selection_device_manager() const {
+    return primary_selection_device_manager_.get();
+  }
+
   WaylandDataDragController* data_drag_controller() const {
     return data_drag_controller_.get();
   }
@@ -122,8 +120,9 @@ class WaylandConnection {
   void Flush();
   void UpdateInputDevices(wl_seat* seat, uint32_t capabilities);
 
-  // Make sure data device is properly initialized
-  void EnsureDataDevice();
+  // Initialize data-related objects if required protocol objects are already
+  // in place, i.e: wl_seat and wl_data_device_manager.
+  void CreateDataObjectsIfReady();
 
   // wl_registry_listener
   static void Global(void* data,
@@ -165,7 +164,6 @@ class WaylandConnection {
 
   std::unique_ptr<WaylandCursor> cursor_;
   std::unique_ptr<WaylandDataDeviceManager> data_device_manager_;
-  std::unique_ptr<WaylandDataDevice> data_device_;
   std::unique_ptr<WaylandClipboard> clipboard_;
   std::unique_ptr<WaylandOutputManager> wayland_output_manager_;
   std::unique_ptr<WaylandCursorPosition> wayland_cursor_position_;
@@ -176,7 +174,6 @@ class WaylandConnection {
 
   std::unique_ptr<GtkPrimarySelectionDeviceManager>
       primary_selection_device_manager_;
-  std::unique_ptr<GtkPrimarySelectionDevice> primary_selection_device_;
 
   std::unique_ptr<WaylandDataDragController> data_drag_controller_;
 

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

@@ -64,7 +64,7 @@ void WaylandDataDeviceBase::RegisterDeferredReadCallback() {
   deferred_read_callback_.reset(wl_display_sync(connection_->display()));
 
   static const wl_callback_listener kListener = {
-      GtkPrimarySelectionDevice::DeferredReadCallback};
+      WaylandDataDeviceBase::DeferredReadCallback};
 
   wl_callback_add_listener(deferred_read_callback_.get(), &kListener, this);
 

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

@@ -4,7 +4,10 @@
 
 #include "ui/ozone/platform/wayland/host/wayland_data_device_manager.h"
 
+#include <memory>
+
 #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_source.h"
 
 namespace ui {
@@ -19,10 +22,15 @@ WaylandDataDeviceManager::WaylandDataDeviceManager(
 
 WaylandDataDeviceManager::~WaylandDataDeviceManager() = default;
 
-wl_data_device* WaylandDataDeviceManager::GetDevice() {
+WaylandDataDevice* WaylandDataDeviceManager::GetDevice() {
   DCHECK(connection_->seat());
-  return wl_data_device_manager_get_data_device(device_manager_.get(),
-                                                connection_->seat());
+  if (!data_device_) {
+    data_device_ = std::make_unique<WaylandDataDevice>(
+        connection_, wl_data_device_manager_get_data_device(
+                         device_manager_.get(), connection_->seat()));
+  }
+  DCHECK(data_device_);
+  return data_device_.get();
 }
 
 std::unique_ptr<WaylandDataSource> WaylandDataDeviceManager::CreateSource() {

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

@@ -15,6 +15,7 @@
 namespace ui {
 
 class WaylandConnection;
+class WaylandDataDevice;
 class WaylandDataSource;
 
 class WaylandDataDeviceManager {
@@ -23,13 +24,15 @@ class WaylandDataDeviceManager {
                            WaylandConnection* connection);
   ~WaylandDataDeviceManager();
 
-  wl_data_device* GetDevice();
+  WaylandDataDevice* GetDevice();
   std::unique_ptr<WaylandDataSource> CreateSource();
 
  private:
   wl::Object<wl_data_device_manager> device_manager_;
 
-  WaylandConnection* connection_;
+  WaylandConnection* const connection_;
+
+  std::unique_ptr<WaylandDataDevice> data_device_;
 
   DISALLOW_COPY_AND_ASSIGN(WaylandDataDeviceManager);
 };

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

@@ -64,15 +64,16 @@ const SkBitmap* GetDragImage(const OSExchangeData& data) {
 }  // namespace
 
 WaylandDataDragController::WaylandDataDragController(
-    WaylandConnection* connection)
+    WaylandConnection* connection,
+    WaylandDataDeviceManager* data_device_manager)
     : connection_(connection),
-      data_device_(connection->wayland_data_device()),
-      data_device_manager_(connection->data_device_manager()),
+      data_device_manager_(data_device_manager),
+      data_device_(data_device_manager->GetDevice()),
       window_manager_(connection->wayland_window_manager()) {
   DCHECK(connection_);
-  DCHECK(data_device_);
-  DCHECK(data_device_manager_);
   DCHECK(window_manager_);
+  DCHECK(data_device_manager_);
+  DCHECK(data_device_);
 }
 
 WaylandDataDragController::~WaylandDataDragController() = default;

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

@@ -38,7 +38,8 @@ class WaylandDataDragController : public WaylandDataDevice::DragDelegate,
  public:
   enum class State { kIdle, kStarted, kTransferring };
 
-  explicit WaylandDataDragController(WaylandConnection* connection);
+  WaylandDataDragController(WaylandConnection* connection,
+                            WaylandDataDeviceManager* data_device_manager);
   WaylandDataDragController(const WaylandDataDragController&) = delete;
   WaylandDataDragController& operator=(const WaylandDataDragController&) =
       delete;
@@ -84,8 +85,8 @@ class WaylandDataDragController : public WaylandDataDevice::DragDelegate,
   void SetOperation(const int operation);
 
   WaylandConnection* const connection_;
-  WaylandDataDevice* const data_device_;
   WaylandDataDeviceManager* const data_device_manager_;
+  WaylandDataDevice* const data_device_;
   WaylandWindowManager* const window_manager_;
 
   State state_ = State::kIdle;

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

@@ -18,6 +18,8 @@
 #include "ui/base/dragdrop/file_info/file_info.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/events/base_event_utils.h"
+#include "ui/ozone/platform/wayland/host/wayland_data_device.h"
+#include "ui/ozone/platform/wayland/host/wayland_data_device_manager.h"
 #include "ui/ozone/platform/wayland/host/wayland_data_drag_controller.h"
 #include "ui/ozone/platform/wayland/host/wayland_data_source.h"
 #include "ui/ozone/platform/wayland/test/constants.h"
@@ -108,6 +110,10 @@ class WaylandDataDragControllerTest : public WaylandTest {
     return connection_->data_drag_controller();
   }
 
+  WaylandDataDevice* data_device() const {
+    return connection_->data_device_manager()->GetDevice();
+  }
+
  protected:
   wl::TestDataDeviceManager* data_device_manager_;
   std::unique_ptr<MockDropHandler> drop_handler_;
@@ -204,8 +210,8 @@ TEST_P(WaylandDataDragControllerTest, ReceiveDrag) {
   });
 
   // The client requests the data and gets callback with it.
-  connection_->wayland_data_device()->RequestData(
-      drag_controller()->data_offer_.get(), kMimeTypeText, std::move(callback));
+  data_device()->RequestData(drag_controller()->data_offer_.get(),
+                             kMimeTypeText, std::move(callback));
   Sync();
 
   data_device_manager_->data_device()->OnLeave();

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

@@ -12,6 +12,8 @@
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/os_exchange_data.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"
 #include "ui/ozone/platform/wayland/host/wayland_data_drag_controller.h"
 #include "ui/ozone/platform/wayland/host/wayland_window.h"
 
@@ -20,6 +22,8 @@ namespace ui {
 WaylandDataSource::WaylandDataSource(wl_data_source* data_source,
                                      WaylandConnection* connection)
     : data_source_(data_source), connection_(connection) {
+  DCHECK(data_source_);
+  DCHECK(connection_);
   static const struct wl_data_source_listener kDataSourceListener = {
       WaylandDataSource::OnTarget,      WaylandDataSource::OnSend,
       WaylandDataSource::OnCancel,      WaylandDataSource::OnDnDDropPerformed,
@@ -36,9 +40,9 @@ void WaylandDataSource::WriteToClipboard(
     if (strcmp(data.first.c_str(), kMimeTypeText) == 0)
       wl_data_source_offer(data_source_.get(), kMimeTypeTextUtf8);
   }
-  wl_data_device_set_selection(connection_->data_device(), data_source_.get(),
+  auto* device = connection_->data_device_manager()->GetDevice();
+  wl_data_device_set_selection(device->data_device(), data_source_.get(),
                                connection_->serial());
-
   connection_->ScheduleFlush();
 }
 

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

@@ -43,16 +43,10 @@ class WaylandDataSource : public WaylandDataSourceBase {
     virtual ~DragDelegate() = default;
   };
 
-  // Takes ownership of data_source.
-  explicit WaylandDataSource(wl_data_source* data_source,
-                             WaylandConnection* connection);
+  // Takes ownership of |data_source|.
+  WaylandDataSource(wl_data_source* data_source, WaylandConnection* connection);
   ~WaylandDataSource() override;
 
-  void set_connection(WaylandConnection* connection) {
-    DCHECK(connection);
-    connection_ = connection;
-  }
-
   void WriteToClipboard(const PlatformClipboard::DataMap& data_map) override;
   void Offer(const ui::OSExchangeData& data, DragDelegate* drag_delegate);
   void SetAction(int operation);
@@ -80,7 +74,8 @@ class WaylandDataSource : public WaylandDataSourceBase {
   void GetDragData(const std::string& mime_type, std::string* contents);
 
   wl::Object<wl_data_source> data_source_;
-  WaylandConnection* connection_ = nullptr;
+
+  WaylandConnection* const connection_;
 
   // Set when this used in DND sessions initiated from Chromium.
   DragDelegate* drag_delegate_ = nullptr;