[DesktopCapturer] FallbackDesktopCapturerWrapper and its tests

webrtc/modules/desktop_capture/fallback_desktop_capturer_wrapper.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/fallback_desktop_capturer_wrapper.h"
+
+#include <utility>
+
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+FallbackDesktopCapturerWrapper::SharedMemoryFactoryWrapper::
+    SharedMemoryFactoryWrapper(std::unique_ptr<SharedMemoryFactory> factory) {
+  RTC_DCHECK(factory);
+  owned_factory_ = std::move(factory);
+  shared_factory_ = owned_factory_.get();
+}
+
+FallbackDesktopCapturerWrapper::SharedMemoryFactoryWrapper::
+    SharedMemoryFactoryWrapper(SharedMemoryFactory* factory) {
+  RTC_DCHECK(factory);
+  shared_factory_ = factory;
+}
+
+FallbackDesktopCapturerWrapper::SharedMemoryFactoryWrapper::
+    ~SharedMemoryFactoryWrapper() = default;
+
+std::unique_ptr<SharedMemoryFactory>
+FallbackDesktopCapturerWrapper::SharedMemoryFactoryWrapper::Wrap() const {
+  return std::unique_ptr<SharedMemoryFactory>(
+      new SharedMemoryFactoryWrapper(owned_factory_.get()));
+}
+
+std::unique_ptr<SharedMemory>
+FallbackDesktopCapturerWrapper::SharedMemoryFactoryWrapper::CreateSharedMemory(
+    size_t size) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  return shared_factory_->CreateSharedMemory(size);
+}
+
+FallbackDesktopCapturerWrapper::FallbackDesktopCapturerWrapper(
+    std::unique_ptr<DesktopCapturer> main_capturer,
+    std::unique_ptr<DesktopCapturer> secondary_capturer)
+    : main_capturer_(std::move(main_capturer)),
+      secondary_capturer_(std::move(secondary_capturer)) {
+  RTC_DCHECK(main_capturer_);
+  RTC_DCHECK(secondary_capturer_);
+}
+
+FallbackDesktopCapturerWrapper::~FallbackDesktopCapturerWrapper() = default;
+
+void FallbackDesktopCapturerWrapper::Start(
+    DesktopCapturer::Callback* callback) {
+  main_capturer_->Start(this);
+  secondary_capturer_->Start(callback);

[Sergey Ulanov, 2017/02/16 19:14:17]

Add a comment there to explain how the callbacks are handled and why secondary
capturer gets the original callback

[Hzj_jie, 2017/02/16 21:31:28]

Done.

+  callback_ = callback;
+}
+
+void FallbackDesktopCapturerWrapper::SetSharedMemoryFactory(
+    std::unique_ptr<SharedMemoryFactory> shared_memory_factory) {
+  if (shared_memory_factory) {
+    shared_memory_factory_.reset(
+        new SharedMemoryFactoryWrapper(std::move(shared_memory_factory)));
+    main_capturer_->SetSharedMemoryFactory(shared_memory_factory_->Wrap());
+    secondary_capturer_->SetSharedMemoryFactory(shared_memory_factory_->Wrap());
+  } else {
+    shared_memory_factory_.reset();
+    main_capturer_->SetSharedMemoryFactory(
+        std::unique_ptr<SharedMemoryFactory>());
+    secondary_capturer_->SetSharedMemoryFactory(
+        std::unique_ptr<SharedMemoryFactory>());
+  }
+}
+
+void FallbackDesktopCapturerWrapper::CaptureFrame() {
+  RTC_DCHECK(callback_);
+  if (main_capturer_permanent_error_) {
+    secondary_capturer_->CaptureFrame();
+  } else {
+    main_capturer_->CaptureFrame();
+  }
+}
+
+void FallbackDesktopCapturerWrapper::SetExcludedWindow(WindowId window) {
+  main_capturer_->SetExcludedWindow(window);
+  secondary_capturer_->SetExcludedWindow(window);
+}
+
+bool FallbackDesktopCapturerWrapper::GetSourceList(SourceList* sources) {
+  if (main_capturer_permanent_error_) {
+    return secondary_capturer_->GetSourceList(sources);
+  }
+  return main_capturer_->GetSourceList(sources);
+}
+
+bool FallbackDesktopCapturerWrapper::SelectSource(SourceId id) {
+  if (main_capturer_permanent_error_) {
+    return secondary_capturer_->SelectSource(id);
+  }
+  return main_capturer_->SelectSource(id) &&
+         secondary_capturer_->SelectSource(id);
+}
+
+bool FallbackDesktopCapturerWrapper::FocusOnSelectedSource() {
+  if (main_capturer_permanent_error_) {
+    return secondary_capturer_->FocusOnSelectedSource();
+  }
+  return main_capturer_->FocusOnSelectedSource() &&
+         secondary_capturer_->FocusOnSelectedSource();
+}
+
+void FallbackDesktopCapturerWrapper::OnCaptureResult(
+    Result result,
+    std::unique_ptr<DesktopFrame> frame) {
+  RTC_DCHECK(callback_);
+  if (result == Result::SUCCESS) {
+    callback_->OnCaptureResult(result, std::move(frame));
+    return;
+  }
+
+  if (result == Result::ERROR_PERMANENT) {
+    main_capturer_permanent_error_ = true;
+  }
+  secondary_capturer_->CaptureFrame();
+}
+
+}  // namespace webrtc