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/+/2216320Reviewed-by: Maksim Sisov <msisov@igalia.com>
Commit-Queue: Nick Yamane <nickdiego@igalia.com>
Cr-Commit-Position: refs/heads/master@{#773235}

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,15 @@ 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),
       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_manager_->GetDevice());
 }
 
 WaylandDataDragController::~WaylandDataDragController() = default;
@@ -100,8 +100,8 @@ void WaylandDataDragController::StartSession(const OSExchangeData& data,
 
   // Starts the wayland drag session setting |this| object as delegate.
   state_ = State::kStarted;
-  data_device_->StartDrag(*data_source_, *origin_window_, icon_surface_.get(),
-                          this);
+  data_device_manager_->GetDevice()->StartDrag(*data_source_, *origin_window_,
+                                               icon_surface_.get(), this);
 }
 
 // Sessions initiated from Chromium, will have |origin_window_| pointing to the
@@ -254,7 +254,7 @@ void WaylandDataDragController::HandleUnprocessedMimeTypes() {
     OnDataTransferFinished(std::move(received_data_));
   } else {
     DCHECK(data_offer_);
-    data_device_->RequestData(
+    data_device_manager_->GetDevice()->RequestData(
         data_offer_.get(), mime_type,
         base::BindOnce(&WaylandDataDragController::OnMimeTypeDataTransferred,
                        weak_factory_.GetWeakPtr()));

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,7 +85,6 @@ class WaylandDataDragController : public WaylandDataDevice::DragDelegate,
   void SetOperation(const int operation);
 
   WaylandConnection* const connection_;
-  WaylandDataDevice* const data_device_;
   WaylandDataDeviceManager* const data_device_manager_;
   WaylandWindowManager* const window_manager_;
 

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;