[DesktopCapture] Detect screen resolution changes in DirectX capturer

webrtc/modules/desktop_capture/win/dxgi_duplicator_controller.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/desktop_capture/win/dxgi_duplicator_controller.h"
 
 #include <windows.h>
 
 #include <algorithm>
+#include <string>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/modules/desktop_capture/desktop_capture_types.h"
+#include "webrtc/modules/desktop_capture/win/screen_capture_utils.h"
 
 namespace webrtc {
 
-DxgiDuplicatorController::Context::Context() {}
+DxgiDuplicatorController::Context::Context() = default;
 
 DxgiDuplicatorController::Context::~Context() {
   DxgiDuplicatorController::Instance()->Unregister(this);
 }
 
+void DxgiDuplicatorController::Context::Reset() {
+  identity_ = 0;
+}
+
 // static
 DxgiDuplicatorController* DxgiDuplicatorController::Instance() {
   // The static instance won't be deleted to ensure it can be used by other
   // threads even during program exiting.
   static DxgiDuplicatorController* instance = new DxgiDuplicatorController();
   return instance;
 }
 
 DxgiDuplicatorController::DxgiDuplicatorController() = default;
 
 DxgiDuplicatorController::~DxgiDuplicatorController() {
   rtc::CritScope lock(&lock_);
   Deinitialize();
 }
 
 bool DxgiDuplicatorController::IsSupported() {
   rtc::CritScope lock(&lock_);
   return Initialize();
 }
 
+void DxgiDuplicatorController::Reset() {
+  rtc::CritScope lock(&lock_);
+  Deinitialize();
+}
+
 bool DxgiDuplicatorController::RetrieveD3dInfo(D3dInfo* info) {
   rtc::CritScope lock(&lock_);
   if (!Initialize()) {
     return false;
   }
   *info = d3d_info_;
   return true;
 }
 
 DesktopVector DxgiDuplicatorController::dpi() {
@@ skipping 118 matching lines @@
     ReleaseDC(nullptr, hdc);
   }
 
   identity_++;
   return true;
 }
 
 void DxgiDuplicatorController::Deinitialize() {
   desktop_rect_ = DesktopRect();
   duplicators_.clear();
+  resolution_change_detector_.Reset();
 }
 
 bool DxgiDuplicatorController::ContextExpired(
     const Context* const context) const {
   return context->identity_ != identity_ ||
          context->contexts_.size() != duplicators_.size();
 }
 
 void DxgiDuplicatorController::Setup(Context* context) {
   if (ContextExpired(context)) {
@@ skipping 17 matching lines @@
   RTC_DCHECK_GE(monitor_id, 0);
   return DoDuplicate(context, monitor_id, target);
 }
 
 bool DxgiDuplicatorController::DoDuplicate(Context* context,
                                            int monitor_id,
                                            SharedDesktopFrame* target) {
   RTC_DCHECK(target);
   target->mutable_updated_region()->Clear();
   rtc::CritScope lock(&lock_);
+  if (DoDuplicateUnlocked(context, monitor_id, target)) {
+    return true;
+  }
+  Deinitialize();
+  return false;
+}
+
+bool DxgiDuplicatorController::DoDuplicateUnlocked(Context* context,
+                                                   int monitor_id,
+                                                   SharedDesktopFrame* target) {
   if (!Initialize()) {
     // Cannot initialize COM components now, display mode may be changing.
     return false;
   }
 
+  if (resolution_change_detector_.IsChanged(
+          GetScreenRect(kFullDesktopScreenId, std::wstring()).size())) {
+    // Resolution of entire screen has been changed, which usually means a new
+    // monitor has been attached or one has been removed. The simplest way is to
+    // Deinitialize() and returns false to indicate downstream components.
+    return false;
+  }
+
   Setup(context);
   if (monitor_id < 0) {
     // Capture entire screen.
     for (size_t i = 0; i < duplicators_.size(); i++) {
       if (!duplicators_[i].Duplicate(&context->contexts_[i], target)) {
-        Deinitialize();
         return false;
       }
     }
     target->set_dpi(dpi());
     return true;
   }
 
   // Capture one monitor.
   for (size_t i = 0; i < duplicators_.size() && i < context->contexts_.size();
        i++) {
     if (monitor_id >= duplicators_[i].screen_count()) {
       monitor_id -= duplicators_[i].screen_count();
     } else {
       if (duplicators_[i].DuplicateMonitor(&context->contexts_[i], monitor_id,
                                            target)) {
         target->set_dpi(dpi());
         return true;
       }
-      Deinitialize();
       return false;
     }
   }
   // id >= ScreenCount(). This is a user error, so we do not need to
   // deinitialize.
   return false;
 }
 
 }  // namespace webrtc