Revert "Get DeviceScaleFactor for the captured monitor/screen"

This reverts commit e20fbb00d0e0219b710da24664e81a10b12c703a.

Reason for revert: Breaks WebRTC roll to Chromium, see:

https://chromium-review.googlesource.com/c/chromium/src/+/6218060

Example of error: https://ci.chromium.org/ui/p/chrome/builders/ci/win-arm64-rel-ready/51821/test-results?sortby=&groupby=

Original change's description:
> Get DeviceScaleFactor for the captured monitor/screen
>
> Accesses DeviceScaleFactor using the windows API
> GetScaleFactorForMonitor and adds it to the DesktopFrame. In a follow-up
> CL, this value is propagated to
> DesktopCaptureDevice::Core::OnCaptureResult where it is added to the
> frame metadata.
>
> In a follow-up CL, add RegisterScaleChangeEvent to get notified whenever
> the device scale factor changes.
>
> Design doc: go/expose-captured-surface-resolution
>
> Bug: chromium:383946052
> Change-Id: I363af33c569419d95ddf31a0cc2f9cecf6fb0c7b
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/374344
> Reviewed-by: Henrik Andreassson <henrika@webrtc.org>
> Reviewed-by: Mark Foltz <mfoltz@chromium.org>
> Commit-Queue: Palak Agarwal <agpalak@google.com>
> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
> Cr-Commit-Position: refs/heads/main@{#43827}

Bug: chromium:383946052
Change-Id: I3065b278939ca0e686ee6da0f0721082bc0c99e8
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/375902
Owners-Override: Mirko Bonadei <mbonadei@webrtc.org>
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#43829}

modules/desktop_capture/desktop_frame.cc

@@ -134,7 +134,6 @@ void DesktopFrame::CopyFrameInfoFrom(const DesktopFrame& other) {
   set_top_left(other.top_left());
   set_icc_profile(other.icc_profile());
   set_may_contain_cursor(other.may_contain_cursor());
-  set_device_scale_factor(other.device_scale_factor());
 }
 
 void DesktopFrame::MoveFrameInfoFrom(DesktopFrame* other) {
@@ -145,7 +144,6 @@ void DesktopFrame::MoveFrameInfoFrom(DesktopFrame* other) {
   set_top_left(other->top_left());
   set_icc_profile(other->icc_profile());
   set_may_contain_cursor(other->may_contain_cursor());
-  set_device_scale_factor(other->device_scale_factor());
 }
 
 bool DesktopFrame::FrameDataIsBlack() const {

modules/desktop_capture/desktop_frame.h

@@ -74,12 +74,6 @@ class RTC_EXPORT DesktopFrame {
   const DesktopVector& dpi() const { return dpi_; }
   void set_dpi(const DesktopVector& dpi) { dpi_ = dpi; }
 
-  std::optional<int32_t> device_scale_factor() const {
-    return device_scale_factor_;
-  }
-  void set_device_scale_factor(std::optional<int32_t> device_scale_factor) {
-    device_scale_factor_ = device_scale_factor;
-  }
   // Indicates if this frame may have the mouse cursor in it. Capturers that
   // support cursor capture may set this to true. If the cursor was
   // outside of the captured area, this may be true even though the cursor is
@@ -178,10 +172,6 @@ class RTC_EXPORT DesktopFrame {
   int64_t capture_time_ms_;
   uint32_t capturer_id_;
   std::vector<uint8_t> icc_profile_;
-  // Currently only used on Windows. It stores the device scale factor of the
-  // captured surface and has distinct values possible in the range of
-  // [100,500].
-  std::optional<int32_t> device_scale_factor_;
 };
 
 // A DesktopFrame that stores data in the heap.

modules/desktop_capture/desktop_frame_unittest.cc

@@ -97,18 +97,6 @@ TEST(DesktopFrameTest, EmptyFrameIsNotBlack) {
   EXPECT_FALSE(frame->FrameDataIsBlack());
 }
 
-TEST(DesktopFrameTest, FrameHasDefaultDeviceScaleFactor) {
-  auto frame = std::make_unique<BasicDesktopFrame>(DesktopSize());
-  EXPECT_EQ(frame->device_scale_factor(), std::nullopt);
-}
-
-TEST(DesktopFrameTest, FrameSetsDeviceScaleFactorCorrectly) {
-  auto frame = std::make_unique<BasicDesktopFrame>(DesktopSize());
-  EXPECT_EQ(frame->device_scale_factor(), std::nullopt);
-  frame->set_device_scale_factor(/*device_scale_factor=*/150);
-  EXPECT_EQ(frame->device_scale_factor(), 150);
-}
-
 TEST(DesktopFrameTest, FrameDataSwitchesBetweenNonBlackAndBlack) {
   auto frame = CreateTestFrame(DesktopRect::MakeXYWH(0, 0, 10, 10), 0xff);
   EXPECT_FALSE(frame->FrameDataIsBlack());

modules/desktop_capture/win/dxgi_adapter_duplicator.cc

@@ -148,13 +148,6 @@ bool DxgiAdapterDuplicator::DuplicateMonitor(Context* context,
                                             DesktopVector(), target);
 }
 
-std::optional<int32_t> DxgiAdapterDuplicator::GetDeviceScaleFactor(
-    int screen_id) const {
-  RTC_DCHECK_GE(screen_id, 0);
-  RTC_DCHECK_LT(screen_id, duplicators_.size());
-  return duplicators_[screen_id].device_scale_factor();
-}
-
 DesktopRect DxgiAdapterDuplicator::ScreenRect(int id) const {
   RTC_DCHECK_GE(id, 0);
   RTC_DCHECK_LT(id, duplicators_.size());

modules/desktop_capture/win/dxgi_adapter_duplicator.h

@@ -55,11 +55,6 @@ class DxgiAdapterDuplicator {
   // Returns desktop rect covered by this DxgiAdapterDuplicator.
   DesktopRect desktop_rect() const { return desktop_rect_; }
 
-  // Returns the device scale factor of screen identified by `screen_id`, which
-  // is owned by this DxgiAdapterDuplicator. `screen_id` should be between [0,
-  // screen_count()).
-  std::optional<int32_t> GetDeviceScaleFactor(int screen_id) const;
-
   // Returns the size of one screen owned by this DxgiAdapterDuplicator. `id`
   // should be between [0, screen_count()).
   DesktopRect ScreenRect(int id) const;

modules/desktop_capture/win/dxgi_duplicator_controller.cc

@@ -189,8 +189,7 @@ DxgiDuplicatorController::Result DxgiDuplicatorController::DoDuplicate(
     return Result::INITIALIZATION_FAILED;
   }
 
-  if (!frame->Prepare(SelectedDesktopSize(monitor_id), monitor_id,
+  if (!frame->Prepare(SelectedDesktopSize(monitor_id), monitor_id)) {
-                      GetDeviceScaleFactor(monitor_id))) {
     return Result::FRAME_PREPARE_FAILED;
   }
 
@@ -394,19 +393,6 @@ DesktopSize DxgiDuplicatorController::desktop_size() const {
   return desktop_rect_.size();
 }
 
-std::optional<int32_t> DxgiDuplicatorController::GetDeviceScaleFactor(
-    int monitor_id) const {
-  RTC_CHECK_GE(monitor_id, 0);
-  for (const auto& duplicator : duplicators_) {
-    if (monitor_id >= duplicator.screen_count()) {
-      monitor_id -= duplicator.screen_count();
-    } else {
-      return duplicator.GetDeviceScaleFactor(monitor_id);
-    }
-  }
-  return std::nullopt;
-}
-
 DesktopRect DxgiDuplicatorController::ScreenRect(int id) const {
   RTC_DCHECK(id >= 0);
   for (size_t i = 0; i < duplicators_.size(); i++) {

modules/desktop_capture/win/dxgi_duplicator_controller.h

@@ -206,13 +206,6 @@ class RTC_EXPORT DxgiDuplicatorController {
   // Returns a DesktopSize to cover entire `desktop_rect_`.
   DesktopSize desktop_size() const RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
-  // Returns the device scale factor of one screen. `monitor_id` should be >= 0.
-  // If system does not support DXGI based capturer, or `monitor_id` is greater
-  // than the total screen count of all the Duplicators, this function returns
-  // std::nullopt.
-  std::optional<int32_t> GetDeviceScaleFactor(int monitor_id) const
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-
   // Returns the size of one screen. `id` should be >= 0. If system does not
   // support DXGI based capturer, or `id` is greater than the total screen count
   // of all the Duplicators, this function returns an empty DesktopRect.

modules/desktop_capture/win/dxgi_frame.cc

@@ -25,9 +25,7 @@ DxgiFrame::DxgiFrame(SharedMemoryFactory* factory) : factory_(factory) {}
 
 DxgiFrame::~DxgiFrame() = default;
 
-bool DxgiFrame::Prepare(DesktopSize size,
+bool DxgiFrame::Prepare(DesktopSize size, DesktopCapturer::SourceId source_id) {
-                        DesktopCapturer::SourceId source_id,
-                        std::optional<int32_t> device_scale_factor) {
   if (source_id != source_id_) {
     // Once the source has been changed, the entire source should be copied.
     source_id_ = source_id;
@@ -59,7 +57,7 @@ bool DxgiFrame::Prepare(DesktopSize size,
     } else {
       frame.reset(new BasicDesktopFrame(size));
     }
-    frame->set_device_scale_factor(device_scale_factor);
+
     frame_ = SharedDesktopFrame::Wrap(std::move(frame));
   }
 

modules/desktop_capture/win/dxgi_frame.h

@@ -45,11 +45,8 @@ class DxgiFrame final {
   // as well as Context class.
   friend class DxgiDuplicatorController;
 
-  // Prepares current instance with desktop size, source id and device scale
+  // Prepares current instance with desktop size and source id.
-  // factor.
+  bool Prepare(DesktopSize size, DesktopCapturer::SourceId source_id);
-  bool Prepare(DesktopSize size,
-               DesktopCapturer::SourceId source_id,
-               std::optional<int32_t> device_scale_factor);
 
   // Should not be called if Prepare() is not executed or returns false.
   Context* context();

modules/desktop_capture/win/dxgi_output_duplicator.cc

@@ -73,9 +73,6 @@ DxgiOutputDuplicator::DxgiOutputDuplicator(const D3dDevice& device,
   RTC_DCHECK(!desktop_rect_.is_empty());
   RTC_DCHECK_GT(desktop_rect_.width(), 0);
   RTC_DCHECK_GT(desktop_rect_.height(), 0);
-  HRESULT hr = GetScaleFactorForMonitor(desc.Monitor, &device_scale_factor_);
-  RTC_LOG_IF(LS_ERROR, FAILED(hr))
-      << "Failed to get scale factor for monitor: " << hr;
 }
 
 DxgiOutputDuplicator::DxgiOutputDuplicator(DxgiOutputDuplicator&& other) =
@@ -421,13 +418,6 @@ int64_t DxgiOutputDuplicator::num_frames_captured() const {
   return num_frames_captured_;
 }
 
-std::optional<DEVICE_SCALE_FACTOR> DxgiOutputDuplicator::device_scale_factor()
-    const {
-  return (device_scale_factor_ != DEVICE_SCALE_FACTOR_INVALID)
-             ? std::make_optional(device_scale_factor_)
-             : std::nullopt;
-}
-
 void DxgiOutputDuplicator::TranslateRect(const DesktopVector& position) {
   desktop_rect_.Translate(position);
   RTC_DCHECK_GE(desktop_rect_.left(), 0);

modules/desktop_capture/win/dxgi_output_duplicator.h

@@ -14,7 +14,6 @@
 #include <comdef.h>
 #include <dxgi.h>
 #include <dxgi1_2.h>
-#include <shellscalingapi.h>
 #include <wrl/client.h>
 
 #include <memory>
@@ -84,10 +83,6 @@ class DxgiOutputDuplicator {
   // How many frames have been captured by this DxigOutputDuplicator.
   int64_t num_frames_captured() const;
 
-  // Device scale factor of the monitor associated with this
-  // DxigOutputDuplicator.
-  std::optional<DEVICE_SCALE_FACTOR> device_scale_factor() const;
-
   // Moves `desktop_rect_`. See DxgiDuplicatorController::TranslateRect().
   void TranslateRect(const DesktopVector& position);
 
@@ -138,7 +133,6 @@ class DxgiOutputDuplicator {
   std::unique_ptr<DxgiTexture> texture_;
   Rotation rotation_;
   DesktopSize unrotated_size_;
-  DEVICE_SCALE_FACTOR device_scale_factor_ = DEVICE_SCALE_FACTOR_INVALID;
 
   // After each AcquireNextFrame() function call, updated_region_(s) of all
   // active Context(s) need to be updated. Since they have missed the

modules/desktop_capture/win/wgc_capture_session.cc

@@ -22,7 +22,6 @@
 #include <utility>
 #include <vector>
 
-#include "modules/desktop_capture/win/screen_capture_utils.h"
 #include "modules/desktop_capture/win/wgc_desktop_frame.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
@@ -100,23 +99,12 @@ bool SizeHasChanged(ABI::Windows::Graphics::SizeInt32 size_new,
 
 }  // namespace
 
-WgcCaptureSession::WgcCaptureSession(intptr_t source_id,
+WgcCaptureSession::WgcCaptureSession(ComPtr<ID3D11Device> d3d11_device,
-                                     ComPtr<ID3D11Device> d3d11_device,
                                      ComPtr<WGC::IGraphicsCaptureItem> item,
                                      ABI::Windows::Graphics::SizeInt32 size)
     : d3d11_device_(std::move(d3d11_device)),
       item_(std::move(item)),
-      size_(size) {
+      size_(size) {}
-  RTC_CHECK(source_id);
-  HMONITOR monitor = 0;
-  if (!GetHmonitorFromDeviceIndex(source_id, &monitor)) {
-    monitor = MonitorFromWindow(reinterpret_cast<HWND>(source_id),
-                                /*dwFlags=*/MONITOR_DEFAULTTONEAREST);
-  }
-  HRESULT hr = GetScaleFactorForMonitor(monitor, &device_scale_factor_);
-  RTC_LOG_IF(LS_ERROR, FAILED(hr))
-      << "Failed to get scale factor for monitor: " << hr;
-}
 
 WgcCaptureSession::~WgcCaptureSession() {
   RemoveEventHandler();
@@ -468,9 +456,6 @@ HRESULT WgcCaptureSession::ProcessFrame() {
   }
 
   DesktopFrame* current_frame = queue_.current_frame();
-  if (device_scale_factor_ != DEVICE_SCALE_FACTOR_INVALID) {
-    current_frame->set_device_scale_factor(device_scale_factor_);
-  }
   DesktopFrame* previous_frame = queue_.previous_frame();
 
   // Will be set to true while copying the frame data to the `current_frame` if

modules/desktop_capture/win/wgc_capture_session.h

@@ -12,7 +12,6 @@
 #define MODULES_DESKTOP_CAPTURE_WIN_WGC_CAPTURE_SESSION_H_
 
 #include <d3d11.h>
-#include <shellscalingapi.h>
 #include <windows.graphics.capture.h>
 #include <windows.graphics.h>
 #include <wrl/client.h>
@@ -30,9 +29,7 @@ namespace webrtc {
 
 class WgcCaptureSession final {
  public:
-  // `source_id` is used to retreive the HMONITOR for the captured window.
   WgcCaptureSession(
-      intptr_t source_id,
       Microsoft::WRL::ComPtr<ID3D11Device> d3d11_device,
       Microsoft::WRL::ComPtr<
           ABI::Windows::Graphics::Capture::IGraphicsCaptureItem> item,
@@ -149,12 +146,6 @@ class WgcCaptureSession final {
   // false.
   DesktopRegion damage_region_;
 
-  // Captures the device scale factor of the monitor where the frame is captured
-  // from. This value is the same as the scale from windows settings. Valid
-  // values are some distinct numbers in the range of [100,500], for example,
-  // 100, 150, 250, etc.
-  DEVICE_SCALE_FACTOR device_scale_factor_ = DEVICE_SCALE_FACTOR_INVALID;
-
   SequenceChecker sequence_checker_;
 };
 

modules/desktop_capture/win/wgc_capturer_win.cc

@@ -342,8 +342,8 @@ void WgcCapturerWin::CaptureFrame() {
         iter_success_pair = ongoing_captures_.emplace(
             std::piecewise_construct,
             std::forward_as_tuple(capture_source_->GetSourceId()),
-            std::forward_as_tuple(capture_source_->GetSourceId(), d3d11_device_,
+            std::forward_as_tuple(d3d11_device_, item,
-                                  item, capture_source_->GetSize()));
+                                  capture_source_->GetSize()));
     RTC_DCHECK(iter_success_pair.second);
     capture_session = &iter_success_pair.first->second;
   } else {