Use FallbackDesktopCapturerWrapper in ScreenCapturerWinMagnifier

webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.cc

 /*
  *  Copyright (c) 2014 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.
  */
 
@@ skipping 17 matching lines @@
 
 // kMagnifierWindowClass has to be "Magnifier" according to the Magnification
 // API. The other strings can be anything.
 static LPCTSTR kMagnifierHostClass = L"ScreenCapturerWinMagnifierHost";
 static LPCTSTR kHostWindowName = L"MagnifierHost";
 static LPCTSTR kMagnifierWindowClass = L"Magnifier";
 static LPCTSTR kMagnifierWindowName = L"MagnifierWindow";
 
 Atomic32 ScreenCapturerWinMagnifier::tls_index_(TLS_OUT_OF_INDEXES);
 
-ScreenCapturerWinMagnifier::ScreenCapturerWinMagnifier(
-    std::unique_ptr<DesktopCapturer> fallback_capturer)
-    : fallback_capturer_(std::move(fallback_capturer)) {}
-
+ScreenCapturerWinMagnifier::ScreenCapturerWinMagnifier() = default;
 ScreenCapturerWinMagnifier::~ScreenCapturerWinMagnifier() {
   // DestroyWindow must be called before MagUninitialize. magnifier_window_ is
   // destroyed automatically when host_window_ is destroyed.
   if (host_window_)
     DestroyWindow(host_window_);
 
   if (magnifier_initialized_)
     mag_uninitialize_func_();
 
   if (mag_lib_handle_)
     FreeLibrary(mag_lib_handle_);
 
   if (desktop_dc_)
     ReleaseDC(NULL, desktop_dc_);
 }
 
 void ScreenCapturerWinMagnifier::Start(Callback* callback) {
   RTC_DCHECK(!callback_);
   RTC_DCHECK(callback);
   callback_ = callback;
 
   if (!InitializeMagnifier()) {
-    LOG_F(LS_WARNING) << "Switching to fallback screen capturer becuase "
-                         "magnifier initialization failed.";
-    StartFallbackCapturer();
+    LOG_F(LS_WARNING) << "Magnifier initialization failed.";
   }
 }
 
 void ScreenCapturerWinMagnifier::SetSharedMemoryFactory(
     std::unique_ptr<SharedMemoryFactory> shared_memory_factory) {
   shared_memory_factory_ = std::move(shared_memory_factory);
 }
 
 void ScreenCapturerWinMagnifier::CaptureFrame() {
-  if (!magnifier_initialized_ ||
-      !magnifier_capture_succeeded_ ||
-      GetSystemMetrics(SM_CMONITORS) != 1) {
-    // Do not try to use the magnifier if it failed before and in multi-screen
-    // setup (where the API crashes sometimes).
-    LOG_F(LS_WARNING) << "Switching to the fallback screen capturer because "
-                         "initialization or last capture attempt failed, or "
-                         "execute on multi-screen system.";
-    StartFallbackCapturer();
-    fallback_capturer_->CaptureFrame();
+  RTC_DCHECK(callback_);
+  if (!magnifier_initialized_) {
+    LOG_F(LS_WARNING) << "Magnifier initialization failed.";
+    callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
     return;
   }
 
   int64_t capture_start_time_nanos = rtc::TimeNanos();
 
   // Switch to the desktop receiving user input if different from the current
   // one.
   std::unique_ptr<Desktop> input_desktop(Desktop::GetInputDesktop());
   if (input_desktop.get() != NULL && !desktop_.IsSame(*input_desktop)) {
     // Release GDI resources otherwise SetThreadDesktop will fail.
     if (desktop_dc_) {
       ReleaseDC(NULL, desktop_dc_);
       desktop_dc_ = NULL;
     }
     // If SetThreadDesktop() fails, the thread is still assigned a desktop.
     // So we can continue capture screen bits, just from the wrong desktop.
     desktop_.SetThreadDesktop(input_desktop.release());
   }
 
   DesktopRect rect = GetScreenRect(current_screen_id_, current_device_key_);
   queue_.MoveToNextFrame();
   CreateCurrentFrameIfNecessary(rect.size());
   // CaptureImage may fail in some situations, e.g. windows8 metro mode. So
   // defer to the fallback capturer if magnifier capturer did not work.
   if (!CaptureImage(rect)) {
-    LOG_F(LS_WARNING) << "Switching to the fallback screen capturer because "
-                         "last capture attempt failed.";
-    StartFallbackCapturer();
-    fallback_capturer_->CaptureFrame();
+    LOG_F(LS_WARNING) << "Magnifier capturer failed to capture a frame.";
+    callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
     return;
   }
 
   // Emit the current frame.
   std::unique_ptr<DesktopFrame> frame = queue_.current_frame()->Share();
   frame->set_dpi(DesktopVector(GetDeviceCaps(desktop_dc_, LOGPIXELSX),
                                GetDeviceCaps(desktop_dc_, LOGPIXELSY)));
   frame->mutable_updated_region()->SetRect(
       DesktopRect::MakeSize(frame->size()));
   frame->set_capture_time_ms((rtc::TimeNanos() - capture_start_time_nanos) /
                              rtc::kNumNanosecsPerMillisec);
   callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
 }
 
 bool ScreenCapturerWinMagnifier::GetSourceList(SourceList* sources) {
   return webrtc::GetScreenList(sources);
 }
 
 bool ScreenCapturerWinMagnifier::SelectSource(SourceId id) {
-  bool valid = IsScreenValid(id, &current_device_key_);
+  if (IsScreenValid(id, &current_device_key_)) {
+    current_screen_id_ = id;
+    return true;
+  }
 
-  // Set current_screen_id_ even if the fallback capturer is being used, so we
-  // can switch back to the magnifier when possible.
-  if (valid)
-    current_screen_id_ = id;
-
-  if (fallback_capturer_started_)
-    fallback_capturer_->SelectSource(id);
-
-  return valid;
+  return false;
 }
 
 void ScreenCapturerWinMagnifier::SetExcludedWindow(WindowId excluded_window) {
   excluded_window_ = (HWND)excluded_window;
   if (excluded_window_ && magnifier_initialized_) {
     set_window_filter_list_func_(
         magnifier_window_, MW_FILTERMODE_EXCLUDE, 1, &excluded_window_);
   }
 }
 
@@ skipping 48 matching lines @@
   owner->OnCaptured(srcdata, srcheader);
 
   return TRUE;
 }
 
 // TODO(zijiehe): These functions are available on Windows Vista or upper, so we
 // do not need to use LoadLibrary and GetProcAddress anymore. Use regular
 // include and function calls instead of a dynamical loaded library.
 bool ScreenCapturerWinMagnifier::InitializeMagnifier() {
   RTC_DCHECK(!magnifier_initialized_);
+
+  if (GetSystemMetrics(SM_CMONITORS) != 1) {
+    // Do not try to use the magnifier if it failed before and in multi-screen

[Hzj_jie, 2017/02/22 19:26:51]

Sorry, I forgot to update this comment. Here "if it failed before" is not
relative.

+    // setup (where the API crashes sometimes).
+    LOG_F(LS_WARNING) << "Magnifier capturer cannot work on multi-screen "
+                         "system.";
+    return false;
+  }
+
   desktop_dc_ = GetDC(nullptr);
 
   mag_lib_handle_ = LoadLibrary(L"Magnification.dll");
   if (!mag_lib_handle_)
     return false;
 
   // Initialize Magnification API function pointers.
   mag_initialize_func_ = reinterpret_cast<MagInitializeFunc>(
       GetProcAddress(mag_lib_handle_, "MagInitialize"));
   mag_uninitialize_func_ = reinterpret_cast<MagUninitializeFunc>(
@@ skipping 146 matching lines @@
   if (!queue_.current_frame() || !queue_.current_frame()->size().equals(size)) {
     std::unique_ptr<DesktopFrame> frame =
         shared_memory_factory_
             ? SharedMemoryDesktopFrame::Create(size,
                                                shared_memory_factory_.get())
             : std::unique_ptr<DesktopFrame>(new BasicDesktopFrame(size));
     queue_.ReplaceCurrentFrame(SharedDesktopFrame::Wrap(std::move(frame)));
   }
 }
 
-void ScreenCapturerWinMagnifier::StartFallbackCapturer() {
-  RTC_DCHECK(fallback_capturer_);
-  if (!fallback_capturer_started_) {
-    fallback_capturer_started_ = true;
-
-    fallback_capturer_->Start(callback_);
-    fallback_capturer_->SelectSource(current_screen_id_);
-  }
-}
-
 }  // namespace webrtc