[WebRTC] Add TwoCapturers test and TwoMagnifierCapturers test

webrtc/modules/desktop_capture/screen_capturer_unittest.cc

 /*
  *  Copyright (c) 2013 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 30 matching lines @@
 const int kTestSharedMemoryId = 123;
 
 namespace webrtc {
 
 namespace {
 
 ACTION_P(SaveUniquePtrArg, dest) {
   *dest = std::move(*arg1);
 }
 
-// Expects |capturer| to successfully capture a frame, and returns it.
-std::unique_ptr<DesktopFrame> CaptureFrame(
-    ScreenCapturer* capturer,
-    MockScreenCapturerCallback* callback) {
-  std::unique_ptr<DesktopFrame> frame;
-  EXPECT_CALL(*callback,
-              OnCaptureResultPtr(DesktopCapturer::Result::SUCCESS, _))
-      .WillOnce(SaveUniquePtrArg(&frame));
-  capturer->Capture(DesktopRegion());
-  EXPECT_TRUE(frame);
-  return frame;
-}
-
 // Returns true if color in |rect| of |frame| is |color|.
 bool ArePixelsColoredBy(const DesktopFrame& frame,
                         DesktopRect rect,
                         RgbaColor color) {
   // updated_region() should cover the painted area.
   DesktopRegion updated_region(frame.updated_region());
   updated_region.IntersectWith(rect);
   if (!updated_region.Equals(DesktopRegion(rect))) {
     return false;
   }
@@ skipping 39 matching lines @@
         drawer->DrawableRegion().height() < kTestArea) {
       LOG(LS_WARNING) << "ScreenDrawer::DrawableRegion() is too small for the "
                          "CaptureUpdatedRegion tests.";
       return;
     }
 
     for (ScreenCapturer* capturer : capturers) {
       capturer->Start(&callback_);
     }
 
+    // Draw a set of |kRectSize| by |kRectSize| rectangles at (|i|, |i|). One of
+    // (controlled by |c|) its primary colors is |i|, and the other two are
+    // 0xff. So we won't draw a white rectangle.
     for (int c = 0; c < 3; c++) {
       for (int i = 0; i < kTestArea - kRectSize; i += 16) {
         DesktopRect rect = DesktopRect::MakeXYWH(i, i, kRectSize, kRectSize);
         rect.Translate(drawer->DrawableRegion().top_left());
         RgbaColor color((c == 0 ? (i & 0xff) : 0x7f),
                         (c == 1 ? (i & 0xff) : 0x7f),
                         (c == 2 ? (i & 0xff) : 0x7f));
         drawer->Clear();
         drawer->DrawRectangle(rect, color);
-
-        const int wait_first_capture_round = 20;
-        for (int j = 0; j < wait_first_capture_round; j++) {
-          drawer->WaitForPendingDraws();
-          std::unique_ptr<DesktopFrame> frame =
-              CaptureFrame(*capturers.begin(), &callback_);
-          if (!frame) {
-            return;
-          }
-
-          if (ArePixelsColoredBy(*frame, rect, color)) {
-            // The first capturer successfully captured the frame we expected.
-            // So the others should also be able to capture it.
-            break;
-          } else {
-            ASSERT_LT(j, wait_first_capture_round);
-          }
-        }
-
-        for (ScreenCapturer* capturer : capturers) {
-          if (capturer == *capturers.begin()) {
-            // TODO(zijiehe): ScreenCapturerX11 and ScreenCapturerWinGdi cannot
-            // capture a correct frame again if screen does not update.
-            continue;
-          }
-          std::unique_ptr<DesktopFrame> frame =
-              CaptureFrame(capturer, &callback_);
-          if (!frame) {
-            return;
-          }
-
-          ASSERT_TRUE(ArePixelsColoredBy(*frame, rect, color));
-        }
+        TestCaptureOneFrame(capturers, drawer.get(), rect, color);
       }
     }
   }
 
   void TestCaptureUpdatedRegion() {
     TestCaptureUpdatedRegion({capturer_.get()});
   }
 
 #if defined(WEBRTC_WIN)
-  bool SetDirectxCapturerMode() {
+  bool CreateDirectxCapturer() {
     if (!ScreenCapturerWinDirectx::IsSupported()) {
       LOG(LS_WARNING) << "Directx capturer is not supported";
       return false;
     }
 
     DesktopCaptureOptions options(DesktopCaptureOptions::CreateDefault());
     options.set_allow_directx_capturer(true);
     capturer_.reset(ScreenCapturer::Create(options));
     return true;
   }
+
+  void CreateMagnifierCapturer() {
+    DesktopCaptureOptions options(DesktopCaptureOptions::CreateDefault());
+    options.set_allow_use_magnification_api(true);
+    capturer_.reset(ScreenCapturer::Create(options));
+  }
 #endif  // defined(WEBRTC_WIN)
 
   std::unique_ptr<ScreenCapturer> capturer_;
   MockScreenCapturerCallback callback_;
+
+ private:
+  // Repeats capturing the frame by using |capturers| one-by-one for 20 times.
+  // Until they succeeded captured a |color| rectangle at |rect|. This function
+  // uses |drawer|->WaitForPendingDraws() between two attempts to wait for the
+  // screen to update.
+  void TestCaptureOneFrame(std::vector<ScreenCapturer*> capturers,
+                           ScreenDrawer* drawer,
+                           DesktopRect rect,
+                           RgbaColor color) {
+    size_t succeeded_capturers = 0;
+    const int wait_capture_round = 20;
+    for (int i = 0; i < wait_capture_round; i++) {
+      drawer->WaitForPendingDraws();
+      for (size_t j = 0; j < capturers.size(); j++) {

[Sergey Ulanov, 2016/09/14 00:08:44]

You could use a range loop here.
 for (auto& capturer : capturers)

[Hzj_jie, 2016/09/14 03:21:54]

I need it to mark capturers[j] = nullptr or capturers.erase(...).

+        if (capturers[j] == nullptr) {
+          // ScreenCapturer should return an empty updated_region() if no
+          // update detected. So we won't test it again if it has captured
+          // the rectangle we drew.
+          continue;
+        }
+        std::unique_ptr<DesktopFrame> frame = CaptureFrame(capturers[j]);
+        if (!frame) {
+          // CaptureFrame() has triggered an assertion failure already, we
+          // only need to return here.
+          return;
+        }
+
+        if (ArePixelsColoredBy(*frame, rect, color)) {
+          capturers[j] = nullptr;
+          succeeded_capturers++;

[Sergey Ulanov, 2016/09/14 00:08:44]

Instead of setting capturers to nullptr and keeping this counter you could just
remove them from capturers vector once they succeed. That would simplify this
code.

[Hzj_jie, 2016/09/14 03:21:54]

It seems like this approach will make the logic more complex. When removing the
first element, the new iterator should be placed before the first element, which
is not allowed in vector.

+        }
+      }
+
+      if (succeeded_capturers == capturers.size()) {
+        break;
+      }
+
+      ASSERT_LT(i, wait_capture_round);

[Sergey Ulanov, 2016/09/14 00:08:44]

Do you really need this assert? It just verifies that a loop index doesn't go
out of range.

[Hzj_jie, 2016/09/14 03:21:54]

Sorry, this is not correct, I expect all capturers should be able to work in 20
rounds.

+    }
+  }
+
+  // Expects |capturer| to successfully capture a frame, and returns it.
+  std::unique_ptr<DesktopFrame> CaptureFrame(ScreenCapturer* capturer) {
+    std::unique_ptr<DesktopFrame> frame;
+    EXPECT_CALL(callback_,
+                OnCaptureResultPtr(DesktopCapturer::Result::SUCCESS, _))
+        .WillOnce(SaveUniquePtrArg(&frame));
+    capturer->Capture(DesktopRegion());
+    EXPECT_TRUE(frame);
+    return frame;
+  }
 };
 
 class FakeSharedMemory : public SharedMemory {
  public:
   FakeSharedMemory(char* buffer, size_t size)
     : SharedMemory(buffer, size, 0, kTestSharedMemoryId),
       buffer_(buffer) {
   }
   virtual ~FakeSharedMemory() {
     delete[] buffer_;
@@ skipping 53 matching lines @@
   ASSERT_TRUE(!it.IsAtEnd());
   EXPECT_TRUE(it.rect().equals(DesktopRect::MakeSize(frame->size())));
   it.Advance();
   EXPECT_TRUE(it.IsAtEnd());
 }
 
 TEST_F(ScreenCapturerTest, CaptureUpdatedRegion) {
   TestCaptureUpdatedRegion();
 }
 
+TEST_F(ScreenCapturerTest, TwoCapturers) {
+  std::unique_ptr<ScreenCapturer> capturer2 = std::move(capturer_);
+  SetUp();
+  TestCaptureUpdatedRegion({capturer_.get(), capturer2.get()});
+}
+
 #if defined(WEBRTC_WIN)
 
 TEST_F(ScreenCapturerTest, UseSharedBuffers) {
   std::unique_ptr<DesktopFrame> frame;
   EXPECT_CALL(callback_,
               OnCaptureResultPtr(DesktopCapturer::Result::SUCCESS, _))
       .WillOnce(SaveUniquePtrArg(&frame));
 
   capturer_->Start(&callback_);
   capturer_->SetSharedMemoryFactory(
       std::unique_ptr<SharedMemoryFactory>(new FakeSharedMemoryFactory()));
   capturer_->Capture(DesktopRegion());
 
   ASSERT_TRUE(frame);
   ASSERT_TRUE(frame->shared_memory());
   EXPECT_EQ(frame->shared_memory()->id(), kTestSharedMemoryId);
 }
 
 TEST_F(ScreenCapturerTest, UseMagnifier) {
-  DesktopCaptureOptions options(DesktopCaptureOptions::CreateDefault());
-  options.set_allow_use_magnification_api(true);
-  capturer_.reset(ScreenCapturer::Create(options));
+  CreateMagnifierCapturer();
 
   std::unique_ptr<DesktopFrame> frame;
   EXPECT_CALL(callback_,
               OnCaptureResultPtr(DesktopCapturer::Result::SUCCESS, _))
       .WillOnce(SaveUniquePtrArg(&frame));
 
   capturer_->Start(&callback_);
   capturer_->Capture(DesktopRegion());
   ASSERT_TRUE(frame);
 }
 
 TEST_F(ScreenCapturerTest, UseDirectxCapturer) {
-  if (!SetDirectxCapturerMode()) {
+  if (!CreateDirectxCapturer()) {
     return;
   }
 
   std::unique_ptr<DesktopFrame> frame;
   EXPECT_CALL(callback_,
               OnCaptureResultPtr(DesktopCapturer::Result::SUCCESS, _))
       .WillOnce(SaveUniquePtrArg(&frame));
 
   capturer_->Start(&callback_);
   capturer_->Capture(DesktopRegion());
   ASSERT_TRUE(frame);
 }
 
 TEST_F(ScreenCapturerTest, UseDirectxCapturerWithSharedBuffers) {
-  if (!SetDirectxCapturerMode()) {
+  if (!CreateDirectxCapturer()) {
     return;
   }
 
   std::unique_ptr<DesktopFrame> frame;
   EXPECT_CALL(callback_,
               OnCaptureResultPtr(DesktopCapturer::Result::SUCCESS, _))
       .WillOnce(SaveUniquePtrArg(&frame));
 
   capturer_->Start(&callback_);
   capturer_->SetSharedMemoryFactory(
       std::unique_ptr<SharedMemoryFactory>(new FakeSharedMemoryFactory()));
   capturer_->Capture(DesktopRegion());
   ASSERT_TRUE(frame);
   ASSERT_TRUE(frame->shared_memory());
   EXPECT_EQ(frame->shared_memory()->id(), kTestSharedMemoryId);
 }
 
 TEST_F(ScreenCapturerTest, CaptureUpdatedRegionWithDirectxCapturer) {
-  if (!SetDirectxCapturerMode()) {
+  if (!CreateDirectxCapturer()) {
     return;
   }
 
   TestCaptureUpdatedRegion();
 }
 
 TEST_F(ScreenCapturerTest, TwoDirectxCapturers) {
-  if (!SetDirectxCapturerMode()) {
+  if (!CreateDirectxCapturer()) {
     return;
   }
 
-  std::unique_ptr<ScreenCapturer> capturer2(capturer_.release());
-  RTC_CHECK(SetDirectxCapturerMode());
+  std::unique_ptr<ScreenCapturer> capturer2 = std::move(capturer_);
+  RTC_CHECK(CreateDirectxCapturer());
   TestCaptureUpdatedRegion({capturer_.get(), capturer2.get()});
 }
 
+TEST_F(ScreenCapturerTest, TwoMagnifierCapturers) {
+  CreateMagnifierCapturer();
+  std::unique_ptr<ScreenCapturer> capturer2 = std::move(capturer_);
+  CreateMagnifierCapturer();
+  TestCaptureUpdatedRegion({capturer_.get(), capturer2.get()});
+}
+
 #endif  // defined(WEBRTC_WIN)
 
 }  // namespace webrtc