Replace static Create() calls with |creator| callbacks

A few proxies/wrappers called static Create() methods themselves, which
then used platform-specific logic to construct the wrapped object. To
further the goal of moving desktop-specific implementation selection to
instances of DesktopInteractionStrategy, this change modifies the
wrappers instead to take a callback that creates the wrapped object.

Bug: 378932951
Change-Id: I0f55d09efac4c705e7faeda0c1d5e4962ac7b6d0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6021579
Reviewed-by: Joe Downing <joedow@chromium.org>
Commit-Queue: Erik Jensen <rkjnsn@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1423449}

remoting/host/desktop_capturer_proxy.cc

@@ -4,30 +4,32 @@
 
 #include "remoting/host/desktop_capturer_proxy.h"
 
-#include <stddef.h>
-
+#include <cstdint>
 #include <memory>
 #include <utility>
 
+#include "base/check.h"
 #include "base/functional/bind.h"
+#include "base/functional/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/scoped_refptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/notimplemented.h"
 #include "base/task/single_thread_task_runner.h"
+#include "base/threading/thread_checker.h"
 #include "build/build_config.h"
-#include "remoting/proto/control.pb.h"
-#include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
-#include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
+#include "third_party/webrtc/modules/desktop_capture/shared_memory.h"
 
 #if BUILDFLAG(IS_CHROMEOS)
 #include "remoting/host/chromeos/frame_sink_desktop_capturer.h"
 #endif
 
-#if BUILDFLAG(IS_LINUX)
-#include "base/environment.h"
-#include "base/nix/xdg_util.h"
+#if defined(WEBRTC_USE_GIO)
+#include "third_party/webrtc/modules/desktop_capture/desktop_capture_metadata.h"
 #endif
 
 namespace remoting {
@@ -45,15 +47,15 @@ class DesktopCapturerProxy::Core : public webrtc::DesktopCapturer::Callback {
     DCHECK(!capturer_);
     capturer_ = std::move(capturer);
   }
-  void CreateCapturer(const webrtc::DesktopCaptureOptions& options,
-                      SourceId id);
+  void CreateCapturer(
+      base::OnceCallback<std::unique_ptr<webrtc::DesktopCapturer>()> creator);
 
   void Start(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner);
   void SetSharedMemoryFactory(
       std::unique_ptr<webrtc::SharedMemoryFactory> shared_memory_factory);
   void SelectSource(SourceId id);
   void CaptureFrame();
-  void SetMaxFrameRate(uint32_t max_frame_rate);
+  void SetMaxFrameRate(std::uint32_t max_frame_rate);
 #if defined(WEBRTC_USE_GIO)
   void GetAndSetMetadata();
 #endif
@@ -81,27 +83,13 @@ DesktopCapturerProxy::Core::~Core() {
 }
 
 void DesktopCapturerProxy::Core::CreateCapturer(
-    const webrtc::DesktopCaptureOptions& options,
-    SourceId id) {
+    base::OnceCallback<std::unique_ptr<webrtc::DesktopCapturer>()> creator) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!capturer_);
 
-#if BUILDFLAG(IS_CHROMEOS)
-  capturer_ = std::make_unique<FrameSinkDesktopCapturer>();
-#elif BUILDFLAG(IS_LINUX)
-  static base::nix::SessionType session_type = base::nix::SessionType::kUnset;
-  if (session_type == base::nix::SessionType::kUnset) {
-    std::unique_ptr<base::Environment> env = base::Environment::Create();
-    session_type = base::nix::GetSessionType(*env);
-  }
+  capturer_ = std::move(creator).Run();
 
-    capturer_ = webrtc::DesktopCapturer::CreateScreenCapturer(options);
-#else   // !BUILDFLAG(IS_CHROMEOS)
-  capturer_ = webrtc::DesktopCapturer::CreateScreenCapturer(options);
-#endif  // !BUILDFLAG(IS_CHROMEOS)
-  if (capturer_) {
-    capturer_->SelectSource(id);
-  } else {
+  if (!capturer_) {
     LOG(ERROR) << "Failed to initialize screen capturer.";
   }
 }
@@ -144,7 +132,7 @@ void DesktopCapturerProxy::Core::CaptureFrame() {
   }
 }
 
-void DesktopCapturerProxy::Core::SetMaxFrameRate(uint32_t max_frame_rate) {
+void DesktopCapturerProxy::Core::SetMaxFrameRate(std::uint32_t max_frame_rate) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (capturer_) {
@@ -191,14 +179,14 @@ DesktopCapturerProxy::~DesktopCapturerProxy() {
 }
 
 void DesktopCapturerProxy::CreateCapturer(
-    const webrtc::DesktopCaptureOptions& options,
-    SourceId id) {
+    base::OnceCallback<std::unique_ptr<webrtc::DesktopCapturer>()> creator) {
   // CreateCapturer() must be called before Start().
   DCHECK(!callback_);
 
   capture_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&Core::CreateCapturer,
-                                base::Unretained(core_.get()), options, id));
+      FROM_HERE,
+      base::BindOnce(&Core::CreateCapturer, base::Unretained(core_.get()),
+                     std::move(creator)));
 }
 
 void DesktopCapturerProxy::set_capturer(
@@ -287,7 +275,7 @@ void DesktopCapturerProxy::OnMetadata(webrtc::DesktopCaptureMetadata metadata) {
 }
 #endif
 
-void DesktopCapturerProxy::SetMaxFrameRate(uint32_t max_frame_rate) {
+void DesktopCapturerProxy::SetMaxFrameRate(std::uint32_t max_frame_rate) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   capture_task_runner_->PostTask(

remoting/host/desktop_capturer_proxy.h

@@ -5,12 +5,17 @@
 #ifndef REMOTING_HOST_DESKTOP_CAPTURER_PROXY_H_
 #define REMOTING_HOST_DESKTOP_CAPTURER_PROXY_H_
 
+#include <cstdint>
 #include <memory>
 
+#include "base/functional/callback_forward.h"
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "remoting/protocol/desktop_capturer.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
+#include "third_party/webrtc/modules/desktop_capture/shared_memory.h"
 
 #if defined(WEBRTC_USE_GIO)
 #include "base/functional/callback.h"
@@ -21,10 +26,6 @@ namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
-namespace webrtc {
-class DesktopCaptureOptions;
-}  // namespace webrtc
-
 namespace remoting {
 
 // DesktopCapturerProxy is responsible for calling webrtc::DesktopCapturer on
@@ -42,8 +43,8 @@ class DesktopCapturerProxy : public DesktopCapturer {
 
   // CreateCapturer() should be used if the capturer needs to be created on the
   // capturer thread. Otherwise, the capturer can be passed to set_capturer().
-  void CreateCapturer(const webrtc::DesktopCaptureOptions& options,
-                      SourceId id);
+  void CreateCapturer(
+      base::OnceCallback<std::unique_ptr<webrtc::DesktopCapturer>()> creator);
   void set_capturer(std::unique_ptr<webrtc::DesktopCapturer> capturer);
 
   // webrtc::DesktopCapturer interface.
@@ -53,7 +54,7 @@ class DesktopCapturerProxy : public DesktopCapturer {
   void CaptureFrame() override;
   bool GetSourceList(SourceList* sources) override;
   bool SelectSource(SourceId id) override;
-  void SetMaxFrameRate(uint32_t max_frame_rate) override;
+  void SetMaxFrameRate(std::uint32_t max_frame_rate) override;
 #if defined(WEBRTC_USE_GIO)
   void GetMetadataAsync(base::OnceCallback<void(webrtc::DesktopCaptureMetadata)>
                             callback) override;

remoting/host/desktop_capturer_wrapper.cc

@@ -4,14 +4,24 @@
 
 #include "remoting/host/desktop_capturer_wrapper.h"
 
+#include <cstdint>
 #include <memory>
 #include <utility>
 
+#include "base/check.h"
+#include "base/functional/callback.h"
 #include "base/logging.h"
+#include "base/notimplemented.h"
+#include "base/threading/thread_checker.h"
 #include "build/build_config.h"
-#include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
+#include "third_party/webrtc/modules/desktop_capture/shared_memory.h"
+
+#if defined(WEBRTC_USE_GIO)
+#include "base/notreached.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_capture_metadata.h"
+#endif
 
 namespace remoting {
 
@@ -24,15 +34,12 @@ DesktopCapturerWrapper::~DesktopCapturerWrapper() {
 }
 
 void DesktopCapturerWrapper::CreateCapturer(
-    const webrtc::DesktopCaptureOptions& options,
-    SourceId id) {
+    base::OnceCallback<std::unique_ptr<webrtc::DesktopCapturer>()> creator) {
   DCHECK(!capturer_);
 
-  capturer_ = webrtc::DesktopCapturer::CreateScreenCapturer(options);
+  capturer_ = std::move(creator).Run();
 
-  if (capturer_) {
-    capturer_->SelectSource(id);
-  } else {
+  if (!capturer_) {
     LOG(ERROR) << "Failed to initialize screen capturer.";
   }
 }
@@ -96,7 +103,7 @@ void DesktopCapturerWrapper::OnCaptureResult(
   callback_->OnCaptureResult(result, std::move(frame));
 }
 
-void DesktopCapturerWrapper::SetMaxFrameRate(uint32_t max_frame_rate) {
+void DesktopCapturerWrapper::SetMaxFrameRate(std::uint32_t max_frame_rate) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (capturer_) {

remoting/host/desktop_capturer_wrapper.h

@@ -5,16 +5,19 @@
 #ifndef REMOTING_HOST_DESKTOP_CAPTURER_WRAPPER_H_
 #define REMOTING_HOST_DESKTOP_CAPTURER_WRAPPER_H_
 
+#include <cstdint>
 #include <memory>
 
+#include "base/functional/callback_forward.h"
 #include "base/memory/raw_ptr.h"
-#include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "remoting/protocol/desktop_capturer.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
+#include "third_party/webrtc/modules/desktop_capture/shared_memory.h"
 
-namespace webrtc {
-class DesktopCaptureOptions;
-}  // namespace webrtc
+#if defined(WEBRTC_USE_GIO)
+#include "third_party/webrtc/modules/desktop_capture/desktop_capture_metadata.h"
+#endif
 
 namespace remoting {
 
@@ -28,8 +31,8 @@ class DesktopCapturerWrapper : public DesktopCapturer,
   DesktopCapturerWrapper& operator=(const DesktopCapturerWrapper&) = delete;
   ~DesktopCapturerWrapper() override;
 
-  void CreateCapturer(const webrtc::DesktopCaptureOptions& options,
-                      SourceId id);
+  void CreateCapturer(
+      base::OnceCallback<std::unique_ptr<webrtc::DesktopCapturer>()> creator);
 
   // webrtc::DesktopCapturer interface.
   void Start(Callback* callback) override;
@@ -38,7 +41,7 @@ class DesktopCapturerWrapper : public DesktopCapturer,
   void CaptureFrame() override;
   bool GetSourceList(SourceList* sources) override;
   bool SelectSource(SourceId id) override;
-  void SetMaxFrameRate(uint32_t max_frame_rate) override;
+  void SetMaxFrameRate(std::uint32_t max_frame_rate) override;
 #if defined(WEBRTC_USE_GIO)
   void GetMetadataAsync(base::OnceCallback<void(webrtc::DesktopCaptureMetadata)>
                             callback) override;

remoting/host/desktop_display_info_monitor.cc

@@ -4,13 +4,18 @@
 
 #include "remoting/host/desktop_display_info_monitor.h"
 
+#include <memory>
 #include <utility>
 
+#include "base/check_op.h"
 #include "base/functional/bind.h"
+#include "base/location.h"
+#include "base/memory/scoped_refptr.h"
+#include "base/sequence_checker.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/time/time.h"
-#include "remoting/base/logging.h"
-#include "remoting/proto/control.pb.h"
+#include "remoting/host/desktop_display_info.h"
+#include "remoting/host/desktop_display_info_loader.h"
 
 namespace remoting {
 
@@ -26,9 +31,10 @@ constexpr base::TimeDelta kPollingInterval = base::Milliseconds(100);
 }  // namespace
 
 DesktopDisplayInfoMonitor::DesktopDisplayInfoMonitor(
-    scoped_refptr<base::SequencedTaskRunner> ui_task_runner)
+    scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
+    std::unique_ptr<DesktopDisplayInfoLoader> info_loader)
     : ui_task_runner_(ui_task_runner),
-      desktop_display_info_loader_(DesktopDisplayInfoLoader::Create()) {
+      desktop_display_info_loader_(std::move(info_loader)) {
   // The loader must be initialized and used on the UI thread (though it can be
   // created on any thread).
   ui_task_runner_->PostTask(

remoting/host/desktop_display_info_monitor.h

@@ -12,6 +12,7 @@
 #include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequence_checker.h"
+#include "base/thread_annotations.h"
 #include "base/timer/timer.h"
 #include "remoting/host/desktop_display_info.h"
 #include "remoting/host/desktop_display_info_loader.h"
@@ -35,7 +36,8 @@ class DesktopDisplayInfoMonitor {
   using Callback = base::RepeatingCallback<CallbackSignature>;
 
   explicit DesktopDisplayInfoMonitor(
-      scoped_refptr<base::SequencedTaskRunner> ui_task_runner);
+      scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
+      std::unique_ptr<DesktopDisplayInfoLoader> info_loader);
 
   DesktopDisplayInfoMonitor(const DesktopDisplayInfoMonitor&) = delete;
   DesktopDisplayInfoMonitor& operator=(const DesktopDisplayInfoMonitor&) =

remoting/host/ipc_desktop_environment.cc

@@ -12,7 +12,6 @@
 #include "base/check.h"
 #include "base/functional/bind.h"
 #include "base/functional/callback.h"
-#include "base/functional/callback_forward.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_refptr.h"

remoting/host/legacy_interaction_strategy.cc

@@ -25,6 +25,7 @@
 #include "remoting/host/desktop_and_cursor_conditional_composer.h"
 #include "remoting/host/desktop_capturer_proxy.h"
 #include "remoting/host/desktop_capturer_wrapper.h"
+#include "remoting/host/desktop_display_info_loader.h"
 #include "remoting/host/desktop_display_info_monitor.h"
 #include "remoting/host/desktop_interaction_strategy.h"
 #include "remoting/host/desktop_resizer.h"
@@ -84,13 +85,13 @@ std::unique_ptr<DesktopCapturer> LegacyInteractionStrategy::CreateVideoCapturer(
   scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner;
 #if BUILDFLAG(IS_CHROMEOS)
   capture_task_runner = ui_task_runner_;
-#else
+#else   // !BUILDFLAG(IS_CHROMEOS)
   // The mouse cursor monitor runs on the |video_capture_task_runner_| so the
   // desktop capturer also needs to run on that task_runner for certain
   // platforms. For example, if we run the desktop capturer on a different
   // thread on Windows, the cursor shape won't be captured when in GDI mode.
   capture_task_runner = video_capture_task_runner_;
-#endif  // !BUILDFLAG(IS_CHROMEOS) && !BUILDFLAG(IS_LINUX)
+#endif  // !BUILDFLAG(IS_CHROMEOS)
 
 #if defined(REMOTING_USE_X11)
   // Workaround for http://crbug.com/1361502: Run each capturer (and
@@ -101,17 +102,30 @@ std::unique_ptr<DesktopCapturer> LegacyInteractionStrategy::CreateVideoCapturer(
   options_.desktop_capture_options()->x_display()->IgnoreXServerGrabs();
 #endif  // REMOTING_USE_X11
 
+  auto creator = base::BindOnce(
+      [](webrtc::DesktopCaptureOptions options, webrtc::ScreenId id) {
+        std::unique_ptr<webrtc::DesktopCapturer> capturer;
+#if BUILDFLAG(IS_CHROMEOS)
+        capturer = std::make_unique<FrameSinkDesktopCapturer>();
+#else   // !BUILDFLAG(IS_CHROMEOS)
+        capturer = webrtc::DesktopCapturer::CreateScreenCapturer(options);
+#endif  // !BUILDFLAG(IS_CHROMEOS)
+        if (capturer) {
+          capturer->SelectSource(id);
+        }
+        return capturer;
+      },
+      *options_.desktop_capture_options(), id);
+
   std::unique_ptr<DesktopCapturer> desktop_capturer;
   if (options_.capture_video_on_dedicated_thread()) {
     auto desktop_capturer_wrapper = std::make_unique<DesktopCapturerWrapper>();
-    desktop_capturer_wrapper->CreateCapturer(
-        *options_.desktop_capture_options(), id);
+    desktop_capturer_wrapper->CreateCapturer(std::move(creator));
     desktop_capturer = std::move(desktop_capturer_wrapper);
   } else {
     auto desktop_capturer_proxy =
         std::make_unique<DesktopCapturerProxy>(std::move(capture_task_runner));
-    desktop_capturer_proxy->CreateCapturer(*options_.desktop_capture_options(),
-                                           id);
+    desktop_capturer_proxy->CreateCapturer(std::move(creator));
     desktop_capturer = std::move(desktop_capturer_proxy);
   }
 
@@ -127,15 +141,28 @@ std::unique_ptr<DesktopCapturer> LegacyInteractionStrategy::CreateVideoCapturer(
 
 std::unique_ptr<DesktopDisplayInfoMonitor>
 LegacyInteractionStrategy::CreateDisplayInfoMonitor() {
-  return std::make_unique<DesktopDisplayInfoMonitor>(ui_task_runner_);
+  return std::make_unique<DesktopDisplayInfoMonitor>(
+      ui_task_runner_, DesktopDisplayInfoLoader::Create());
 }
 
 std::unique_ptr<webrtc::MouseCursorMonitor>
 LegacyInteractionStrategy::CreateMouseCursorMonitor() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  return std::make_unique<MouseCursorMonitorProxy>(
-      video_capture_task_runner_, *options_.desktop_capture_options());
+  auto creator = base::BindOnce(
+      [](webrtc::DesktopCaptureOptions options)
+          -> std::unique_ptr<webrtc::MouseCursorMonitor> {
+#if BUILDFLAG(IS_CHROMEOS)
+        return std::make_unique<MouseCursorMonitorAura>();
+#else   // BUILDFLAG(IS_CHROMEOS)
+        return base::WrapUnique(webrtc::MouseCursorMonitor::CreateForScreen(
+            options, webrtc::kFullDesktopScreenId));
+#endif  // BUILDFLAG(IS_CHROMEOS)
+      },
+      *options_.desktop_capture_options());
+
+  return std::make_unique<MouseCursorMonitorProxy>(video_capture_task_runner_,
+                                                   std::move(creator));
 }
 
 std::unique_ptr<KeyboardLayoutMonitor>

remoting/host/me2me_desktop_environment.cc

@@ -132,12 +132,12 @@ std::string Me2MeDesktopEnvironment::GetCapabilities() const {
 Me2MeDesktopEnvironment::Me2MeDesktopEnvironment(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    std::unique_ptr<DesktopInteractionStrategy> platform_session,
+    std::unique_ptr<DesktopInteractionStrategy> interaction_strategy,
     base::WeakPtr<ClientSessionControl> client_session_control,
     const DesktopEnvironmentOptions& options)
     : BasicDesktopEnvironment(caller_task_runner,
                               ui_task_runner,
-                              std::move(platform_session),
+                              std::move(interaction_strategy),
                               client_session_control,
                               options) {
   DCHECK(caller_task_runner->BelongsToCurrentThread());

remoting/host/mouse_cursor_monitor_proxy.cc

@@ -5,14 +5,19 @@
 #include "remoting/host/mouse_cursor_monitor_proxy.h"
 
 #include <memory>
+#include <utility>
 
+#include "base/check.h"
 #include "base/functional/bind.h"
+#include "base/functional/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/scoped_refptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/task/single_thread_task_runner.h"
+#include "base/threading/thread_checker.h"
 #include "build/build_config.h"
-#include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
-#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
 
@@ -32,14 +37,13 @@ class MouseCursorMonitorProxy::Core
 
   ~Core() override;
 
-  void CreateMouseCursorMonitor(const webrtc::DesktopCaptureOptions& options);
+  void CreateMouseCursorMonitor(
+      base::OnceCallback<std::unique_ptr<webrtc::MouseCursorMonitor>()>
+          creator);
 
   void Init(webrtc::MouseCursorMonitor::Mode mode);
   void Capture();
 
-  void SetMouseCursorMonitorForTests(
-      std::unique_ptr<webrtc::MouseCursorMonitor> mouse_cursor_monitor);
-
  private:
   // webrtc::MouseCursorMonitor::Callback implementation.
   void OnMouseCursor(webrtc::MouseCursor* mouse_cursor) override;
@@ -64,15 +68,11 @@ MouseCursorMonitorProxy::Core::~Core() {
 }
 
 void MouseCursorMonitorProxy::Core::CreateMouseCursorMonitor(
-    const webrtc::DesktopCaptureOptions& options) {
+    base::OnceCallback<std::unique_ptr<webrtc::MouseCursorMonitor>()> creator) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-#if BUILDFLAG(IS_CHROMEOS)
-  mouse_cursor_monitor_ = std::make_unique<MouseCursorMonitorAura>();
-#else   // BUILDFLAG(IS_CHROMEOS)
-  mouse_cursor_monitor_.reset(webrtc::MouseCursorMonitor::CreateForScreen(
-      options, webrtc::kFullDesktopScreenId));
-#endif  // BUILDFLAG(IS_CHROMEOS)
+  mouse_cursor_monitor_ = std::move(creator).Run();
+
   if (!mouse_cursor_monitor_) {
     LOG(ERROR) << "Failed to initialize MouseCursorMonitor.";
   }
@@ -95,11 +95,6 @@ void MouseCursorMonitorProxy::Core::Capture() {
   }
 }
 
-void MouseCursorMonitorProxy::Core::SetMouseCursorMonitorForTests(
-    std::unique_ptr<webrtc::MouseCursorMonitor> mouse_cursor_monitor) {
-  mouse_cursor_monitor_ = std::move(mouse_cursor_monitor);
-}
-
 void MouseCursorMonitorProxy::Core::OnMouseCursor(webrtc::MouseCursor* cursor) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ -120,12 +115,13 @@ void MouseCursorMonitorProxy::Core::OnMouseCursorPosition(
 
 MouseCursorMonitorProxy::MouseCursorMonitorProxy(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
-    const webrtc::DesktopCaptureOptions& options)
+    base::OnceCallback<std::unique_ptr<webrtc::MouseCursorMonitor>()> creator)
     : capture_task_runner_(capture_task_runner) {
   core_ = std::make_unique<Core>(weak_factory_.GetWeakPtr());
   capture_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&Core::CreateMouseCursorMonitor,
-                                base::Unretained(core_.get()), options));
+      FROM_HERE,
+      base::BindOnce(&Core::CreateMouseCursorMonitor,
+                     base::Unretained(core_.get()), std::move(creator)));
 }
 
 MouseCursorMonitorProxy::~MouseCursorMonitorProxy() {
@@ -146,14 +142,6 @@ void MouseCursorMonitorProxy::Capture() {
       FROM_HERE, base::BindOnce(&Core::Capture, base::Unretained(core_.get())));
 }
 
-void MouseCursorMonitorProxy::SetMouseCursorMonitorForTests(
-    std::unique_ptr<webrtc::MouseCursorMonitor> mouse_cursor_monitor) {
-  capture_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&Core::SetMouseCursorMonitorForTests,
-                                base::Unretained(core_.get()),
-                                std::move(mouse_cursor_monitor)));
-}
-
 void MouseCursorMonitorProxy::OnMouseCursor(
     std::unique_ptr<webrtc::MouseCursor> cursor) {
   DCHECK(thread_checker_.CalledOnValidThread());

remoting/host/mouse_cursor_monitor_proxy.h

@@ -7,27 +7,26 @@
 
 #include <memory>
 
+#include "base/functional/callback_forward.h"
 #include "base/memory/raw_ptr.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
-namespace webrtc {
-class DesktopCaptureOptions;
-}  // namespace webrtc
-
 namespace remoting {
 
 class MouseCursorMonitorProxy : public webrtc::MouseCursorMonitor {
  public:
   MouseCursorMonitorProxy(
       scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
-      const webrtc::DesktopCaptureOptions& options);
+      base::OnceCallback<std::unique_ptr<webrtc::MouseCursorMonitor>()>
+          creator);
 
   MouseCursorMonitorProxy(const MouseCursorMonitorProxy&) = delete;
   MouseCursorMonitorProxy& operator=(const MouseCursorMonitorProxy&) = delete;
@@ -38,9 +37,6 @@ class MouseCursorMonitorProxy : public webrtc::MouseCursorMonitor {
   void Init(Callback* callback, Mode mode) override;
   void Capture() override;
 
-  void SetMouseCursorMonitorForTests(
-      std::unique_ptr<webrtc::MouseCursorMonitor> mouse_cursor_monitor);
-
  private:
   class Core;
 

remoting/host/mouse_cursor_monitor_proxy_unittest.cc

@@ -5,10 +5,11 @@
 #include "remoting/host/mouse_cursor_monitor_proxy.h"
 
 #include <memory>
-#include <utility>
 
-#include "base/functional/bind.h"
+#include "base/check.h"
+#include "base/functional/callback_helpers.h"
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/test/task_environment.h"
@@ -17,8 +18,8 @@
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
 
@@ -38,7 +39,7 @@ static const int kHotspotY = 12;
 
 class ThreadCheckMouseCursorMonitor : public webrtc::MouseCursorMonitor {
  public:
-  ThreadCheckMouseCursorMonitor(
+  explicit ThreadCheckMouseCursorMonitor(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : task_runner_(task_runner), callback_(nullptr) {}
 
@@ -118,10 +119,9 @@ TEST_F(MouseCursorMonitorProxyTest, CursorShape) {
   // Initialize the proxy.
   proxy_ = std::make_unique<MouseCursorMonitorProxy>(
       capture_thread_.task_runner(),
-      webrtc::DesktopCaptureOptions::CreateDefault());
-  proxy_->SetMouseCursorMonitorForTests(
-      std::make_unique<ThreadCheckMouseCursorMonitor>(
-          capture_thread_.task_runner()));
+      base::ReturnValueOnce<std::unique_ptr<webrtc::MouseCursorMonitor>>(
+          std::make_unique<ThreadCheckMouseCursorMonitor>(
+              capture_thread_.task_runner())));
   proxy_->Init(this, webrtc::MouseCursorMonitor::SHAPE_ONLY);
   proxy_->Capture();