[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>

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

map<> is not used in this file

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

Done.

+#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);
+}
+
+class FakeSharedMemory : public SharedMemory {
+ public:
+  explicit FakeSharedMemory(size_t size);
+  ~FakeSharedMemory() override = default;
+
+ private:
+  static int kId;

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

nit: Does this need to be a class member?

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

Otherwise I need to add a long prefix to indicate it's for FakeSharedMemory.
Say, kFakeSharedMemoryId, which, I think, equals to FakeSharedMemory::kId. I do
not have a strong opinion. Indeed, I have typed at least 20x times characters
here to explain the reason. :)
If you think it's important, I am happy to move it out of the class.

[Sergey Ulanov, 2017/02/17 20:16:23]

Doesn't really matter much, but most other consts in other places are declared
non-nested, except when they are shared outside of a single .cc file. 
But I've just realized that this is not a const. Then it shouldn't use
const-style name. Rename it to next_id_?

[Hzj_jie, 2017/02/17 21:55:18]

Done.

+};
+
+// static
+int FakeSharedMemory::kId = 0;
+
+FakeSharedMemory::FakeSharedMemory(size_t size)
+    : SharedMemory(nullptr, size, 0, kId++) {}
+
+class FakeSharedMemoryFactory : public SharedMemoryFactory {
+ public:
+  FakeSharedMemoryFactory() = default;
+  ~FakeSharedMemoryFactory() override = default;
+
+  std::unique_ptr<SharedMemory> CreateSharedMemory(size_t size) override;
+};
+
+std::unique_ptr<SharedMemory> FakeSharedMemoryFactory::CreateSharedMemory(
+    size_t size) {
+  return std::unique_ptr<SharedMemory>(new FakeSharedMemory(size));
+}
+
+}  // namespace
+
+class FallbackDesktopCapturerWrapperTest : public testing::Test,
+                                           public DesktopCapturer::Callback {
+ public:
+  FallbackDesktopCapturerWrapperTest();
+  ~FallbackDesktopCapturerWrapperTest() override = default;
+
+ protected:
+  FakeDesktopCapturer* main_capturer();
+  FakeDesktopCapturer* secondary_capturer();

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

Just make the fields protected. Technically it contradicts the style guide, but
protected fields are common in tests and I don't think there are any downsides

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

Done.

+  FallbackDesktopCapturerWrapper* wrapper();
+  const std::vector<std::pair<DesktopCapturer::Result, bool>>& results() const;
+
+ 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()->num_capture_attempts(), 1);
+  ASSERT_EQ(main_capturer()->num_frames_captured(), 1);
+  ASSERT_EQ(secondary_capturer()->num_capture_attempts(), 0);
+  ASSERT_EQ(secondary_capturer()->num_frames_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()->num_capture_attempts(), 3);
+  ASSERT_EQ(main_capturer()->num_frames_captured(), 2);
+  ASSERT_EQ(secondary_capturer()->num_capture_attempts(), 1);
+  ASSERT_EQ(secondary_capturer()->num_frames_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()->num_capture_attempts(), 2);
+  ASSERT_EQ(main_capturer()->num_frames_captured(), 1);
+  ASSERT_EQ(secondary_capturer()->num_capture_attempts(), 2);
+  ASSERT_EQ(secondary_capturer()->num_frames_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()->num_capture_attempts(), 2);
+  ASSERT_EQ(main_capturer()->num_frames_captured(), 1);
+  ASSERT_EQ(secondary_capturer()->num_capture_attempts(), 5);
+  ASSERT_EQ(secondary_capturer()->num_frames_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));
+}
+
+TEST(SharedMemoryFactoryWrapperTest, CreateShared) {
+  FallbackDesktopCapturerWrapper::SharedMemoryFactoryWrapper factory(
+      std::unique_ptr<SharedMemoryFactory>(new FakeSharedMemoryFactory()));
+  std::unique_ptr<SharedMemory> shared_memory = factory.CreateSharedMemory(0);
+  ASSERT_TRUE(shared_memory);
+  ASSERT_EQ(shared_memory->id(), 0);
+  ASSERT_EQ(shared_memory->size(), 0u);
+
+  std::unique_ptr<SharedMemoryFactory> shared1 = factory.Wrap();
+  ASSERT_TRUE(shared1);
+  shared_memory = shared1->CreateSharedMemory(199);
+  ASSERT_TRUE(shared_memory);
+  ASSERT_EQ(shared_memory->id(), 1);
+  ASSERT_EQ(shared_memory->size(), 199u);
+
+  std::unique_ptr<SharedMemoryFactory> shared2 = factory.Wrap();
+  ASSERT_TRUE(shared2);
+  shared_memory = shared2->CreateSharedMemory(299);
+  ASSERT_TRUE(shared_memory);
+  ASSERT_EQ(shared_memory->id(), 2);
+  ASSERT_EQ(shared_memory->size(), 299u);
+
+  shared_memory = factory.CreateSharedMemory(399);
+  ASSERT_TRUE(shared_memory);
+  ASSERT_EQ(shared_memory->id(), 3);
+  ASSERT_EQ(shared_memory->size(), 399u);
+
+  shared_memory = shared1->CreateSharedMemory(499);
+  ASSERT_TRUE(shared_memory);
+  ASSERT_EQ(shared_memory->id(), 4);
+  ASSERT_EQ(shared_memory->size(), 499u);
+
+  shared_memory = shared2->CreateSharedMemory(599);
+  ASSERT_TRUE(shared_memory);
+  ASSERT_EQ(shared_memory->id(), 5);
+  ASSERT_EQ(shared_memory->size(), 599u);
+}
+
+}  // namespace webrtc