[DesktopCapturer] FallbackDesktopCapturerWrapper and its tests

webrtc/modules/desktop_capture/fallback_desktop_capturer_wrapper_unittest.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 <map>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "webrtc/modules/desktop_capture/desktop_capturer.h"
+#include "webrtc/modules/desktop_capture/desktop_frame_generator.h"
+#include "webrtc/modules/desktop_capture/fake_desktop_capturer.h"
+#include "webrtc/test/gtest.h"
+
+namespace webrtc {
+
+namespace {
+
+std::unique_ptr<DesktopCapturer> CreateDesktopCapturer(
+    PainterDesktopFrameGenerator* frame_generator) {
+  std::unique_ptr<FakeDesktopCapturer> capturer(new FakeDesktopCapturer());
+  capturer->set_frame_generator(frame_generator);
+  return std::move(capturer);
+}
+
+}  // namespace
+
+class FallbackDesktopCapturerWrapperTest : public testing::Test,
+                                           public DesktopCapturer::Callback {
+ public:
+  FallbackDesktopCapturerWrapperTest();
+  ~FallbackDesktopCapturerWrapperTest() override = default;
+
+ protected:
+  FakeDesktopCapturer* main_capturer();
+  FakeDesktopCapturer* secondary_capturer();
+  FallbackDesktopCapturerWrapper* wrapper();
+  const std::vector<std::pair<DesktopCapturer::Result, bool>>& results() const;

[Jamie, 2017/02/15 18:43:48]

Optional: This is probably overkill for a test. You can make the members all
protected and access them directly from the tests.

+
+ private:
+  // DesktopCapturer::Callback interface
+  void OnCaptureResult(DesktopCapturer::Result result,
+                       std::unique_ptr<DesktopFrame> frame) override;
+
+  std::vector<std::pair<DesktopCapturer::Result, bool>> results_;
+  FakeDesktopCapturer* main_capturer_ = nullptr;
+  FakeDesktopCapturer* secondary_capturer_ = nullptr;
+  std::unique_ptr<FallbackDesktopCapturerWrapper> wrapper_;
+  PainterDesktopFrameGenerator frame_generator;
+};
+
+FallbackDesktopCapturerWrapperTest::FallbackDesktopCapturerWrapperTest() {
+  frame_generator.size()->set(1024, 768);
+  std::unique_ptr<DesktopCapturer> main_capturer =
+      CreateDesktopCapturer(&frame_generator);
+  std::unique_ptr<DesktopCapturer> secondary_capturer =
+      CreateDesktopCapturer(&frame_generator);
+  main_capturer_ = static_cast<FakeDesktopCapturer*>(main_capturer.get());
+  secondary_capturer_
+      = static_cast<FakeDesktopCapturer*>(secondary_capturer.get());
+  wrapper_.reset(new FallbackDesktopCapturerWrapper(
+      std::move(main_capturer), std::move(secondary_capturer)));
+  wrapper_->Start(this);
+}
+
+FakeDesktopCapturer* FallbackDesktopCapturerWrapperTest::main_capturer() {
+  return main_capturer_;
+}
+
+FakeDesktopCapturer* FallbackDesktopCapturerWrapperTest::secondary_capturer() {
+  return secondary_capturer_;
+}
+
+FallbackDesktopCapturerWrapper* FallbackDesktopCapturerWrapperTest::wrapper() {
+  return wrapper_.get();
+}
+
+const std::vector<std::pair<DesktopCapturer::Result, bool>>&
+FallbackDesktopCapturerWrapperTest::results() const {
+  return results_;
+}
+
+void FallbackDesktopCapturerWrapperTest::OnCaptureResult(
+    DesktopCapturer::Result result,
+    std::unique_ptr<DesktopFrame> frame) {
+  results_.emplace_back(result, !!frame);
+}
+
+TEST_F(FallbackDesktopCapturerWrapperTest, MainNeverFailed) {
+  wrapper()->CaptureFrame();
+  ASSERT_EQ(main_capturer()->capture_attempts(), 1);
+  ASSERT_EQ(main_capturer()->frame_captured(), 1);
+  ASSERT_EQ(secondary_capturer()->capture_attempts(), 0);
+  ASSERT_EQ(secondary_capturer()->frame_captured(), 0);
+  ASSERT_EQ(results().size(), 1U);
+  ASSERT_EQ(results()[0],
+            std::make_pair(DesktopCapturer::Result::SUCCESS, true));
+}
+
+TEST_F(FallbackDesktopCapturerWrapperTest, MainFailedTemporarily) {
+  wrapper()->CaptureFrame();
+  main_capturer()->set_result(DesktopCapturer::Result::ERROR_TEMPORARY);
+  wrapper()->CaptureFrame();
+  main_capturer()->set_result(DesktopCapturer::Result::SUCCESS);
+  wrapper()->CaptureFrame();
+
+  ASSERT_EQ(main_capturer()->capture_attempts(), 3);
+  ASSERT_EQ(main_capturer()->frame_captured(), 2);
+  ASSERT_EQ(secondary_capturer()->capture_attempts(), 1);
+  ASSERT_EQ(secondary_capturer()->frame_captured(), 1);
+  ASSERT_EQ(results().size(), 3U);
+  for (int i = 0; i < 3; i++) {
+    ASSERT_EQ(results()[i],
+              std::make_pair(DesktopCapturer::Result::SUCCESS, true));
+  }
+}
+
+TEST_F(FallbackDesktopCapturerWrapperTest, MainFailedPermanently) {
+  wrapper()->CaptureFrame();
+  main_capturer()->set_result(DesktopCapturer::Result::ERROR_PERMANENT);
+  wrapper()->CaptureFrame();
+  main_capturer()->set_result(DesktopCapturer::Result::SUCCESS);
+  wrapper()->CaptureFrame();
+
+  ASSERT_EQ(main_capturer()->capture_attempts(), 2);
+  ASSERT_EQ(main_capturer()->frame_captured(), 1);
+  ASSERT_EQ(secondary_capturer()->capture_attempts(), 2);
+  ASSERT_EQ(secondary_capturer()->frame_captured(), 2);
+  ASSERT_EQ(results().size(), 3U);
+  for (int i = 0; i < 3; i++) {
+    ASSERT_EQ(results()[i],
+              std::make_pair(DesktopCapturer::Result::SUCCESS, true));
+  }
+}
+
+TEST_F(FallbackDesktopCapturerWrapperTest, BothFailed) {
+  wrapper()->CaptureFrame();
+  main_capturer()->set_result(DesktopCapturer::Result::ERROR_PERMANENT);
+  wrapper()->CaptureFrame();
+  main_capturer()->set_result(DesktopCapturer::Result::SUCCESS);
+  wrapper()->CaptureFrame();
+  secondary_capturer()->set_result(DesktopCapturer::Result::ERROR_TEMPORARY);
+  wrapper()->CaptureFrame();
+  secondary_capturer()->set_result(DesktopCapturer::Result::ERROR_PERMANENT);
+  wrapper()->CaptureFrame();
+  wrapper()->CaptureFrame();
+
+  ASSERT_EQ(main_capturer()->capture_attempts(), 2);
+  ASSERT_EQ(main_capturer()->frame_captured(), 1);
+  ASSERT_EQ(secondary_capturer()->capture_attempts(), 5);
+  ASSERT_EQ(secondary_capturer()->frame_captured(), 2);
+  ASSERT_EQ(results().size(), 6U);
+  for (int i = 0; i < 3; i++) {
+    ASSERT_EQ(results()[i],
+              std::make_pair(DesktopCapturer::Result::SUCCESS, true));
+  }
+  ASSERT_EQ(results()[3],
+            std::make_pair(DesktopCapturer::Result::ERROR_TEMPORARY, false));
+  ASSERT_EQ(results()[4],
+            std::make_pair(DesktopCapturer::Result::ERROR_PERMANENT, false));
+  ASSERT_EQ(results()[5],
+            std::make_pair(DesktopCapturer::Result::ERROR_PERMANENT, false));
+}
+
+}  // namespace webrtc