[WebRTC] A real ScreenCapturer 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.
  */
 
+#include <string.h>
+
+#include <algorithm>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "webrtc/modules/desktop_capture/screen_capturer.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "webrtc/modules/desktop_capture/desktop_frame.h"
 #include "webrtc/modules/desktop_capture/desktop_region.h"
 #include "webrtc/modules/desktop_capture/screen_capturer_mock_objects.h"
+#include "webrtc/modules/desktop_capture/screen_painter.h"
+#include "webrtc/system_wrappers/include/sleep.h"
 
 #if defined(WEBRTC_WIN)
 #include "webrtc/modules/desktop_capture/win/screen_capturer_win_directx.h"
 #endif  // defined(WEBRTC_WIN)
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Return;
 
 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;
+}
+
+// Expects color in |rect| of |frame| is |color|.
+void ExpectPixelsAreColoredBy(const DesktopFrame& frame,
+                              DesktopRect rect,
+                              ScreenPainter::Color color) {
+  uint8_t* row = frame.GetFrameDataAtPos(rect.top_left());
+  for (int i = 0; i < rect.height(); i++) {
+    uint8_t* column = row;
+    for (int j = 0; j < rect.width(); j++) {
+      ASSERT_EQ(color, column);
+      column += DesktopFrame::kBytesPerPixel;
+    }
+    row += frame.stride();
+  }
+}
+
+// Finds the visible region and offset of ScreenDrawer drawable region in
+// ScreenCapturer reachable area. The top left of the DesktopRect returned is
+// the offset of ScreenDrawer drawable region, which maps to (0, 0) of
+// ScreenDrawer::DrawableRegion(). The size of the DesktopRect indicates the
+// size of visible region. So to ensure rendering a shape in the visible area of
+// ScreenCapturer, you can randomize points within the DesktopRect::size() and
+// use DesktopRect::Translate(-top_left().left(), -top_left().top()) or
+// DesktopVector::subtract(top_left()) to translate into the coordinate of
+// ScreenDrawer. This function returns an empty DesktopRect if calibration
+// failed.
+DesktopRect CalibrateScreenDrawerPosition(
+    ScreenPainter* painter,
+    ScreenCapturer* capturer,
+    MockScreenCapturerCallback* callback) {
+  const int kAnchorSize = 20;
+  if (painter->DrawableRegion().width() < kAnchorSize ||
+      painter->DrawableRegion().height() < 1) {
+    LOG(LS_WARNING) << "DrawableRegion is too small for calibration.";
+    return DesktopRect();
+  }
+  std::vector<ScreenPainter::Color> anchor_colors;
+  painter->Clear();
+  painter->DrawColorfulHorizontalLine(DesktopVector(), kAnchorSize,
+                                      &anchor_colors);
+  // We do not need a very accurate positiin, so reduce the sample rate by
+  // 1/256. This usually does not make too much difference.
+  for (int i = std::max(painter->DrawableRegion().width(),
+                        painter->DrawableRegion().height()) -
+               1;
+       i > 0; i -= 16) {
+    for (int j = i; j < std::max(painter->DrawableRegion().width(),
+                                 painter->DrawableRegion().height()) -
+                            1;
+         j += anchor_colors.size() * 16) {
+      painter->DrawColorfulHorizontalLine(DesktopVector(j, i), anchor_colors);
+    }
+  }
+  painter->WaitForPendingPaintings();
+
+  std::unique_ptr<DesktopFrame> frame = CaptureFrame(capturer, callback);
+  painter->Clear();
+  if (!frame) {
+    return DesktopRect();
+  }
+
+  const uint8_t* const end =
+      frame->data() + frame->stride() * frame->size().height() -
+      anchor_colors.size() * sizeof(ScreenPainter::Color);
+  DesktopVector top_left(-1, -1);
+  DesktopVector right_bottom;
+  for (const uint8_t* i = frame->data(); i < end;
+       i += DesktopFrame::kBytesPerPixel) {
+    if (ScreenPainter::Color::PixelsMatch(anchor_colors, i)) {
+      right_bottom = frame->GetPosAtFrameData(i);
+      if (top_left.x() < 0 && top_left.y() < 0) {
+        top_left = right_bottom;
+      }
+    }
+  }
+
+  if (top_left.x() >= 0 && top_left.y() >= 0) {
+    return DesktopRect::MakeLTRB(top_left, right_bottom);
+  }
+
+  return DesktopRect();
+}
+
+}  // namespace
+
 class ScreenCapturerTest : public testing::Test {
  public:
   void SetUp() override {
     capturer_.reset(
         ScreenCapturer::Create(DesktopCaptureOptions::CreateDefault()));
   }
 
  protected:
   std::unique_ptr<ScreenCapturer> capturer_;
   MockScreenCapturerCallback callback_;
@@ skipping 20 matching lines @@
 
   std::unique_ptr<SharedMemory> CreateSharedMemory(size_t size) override {
     return std::unique_ptr<SharedMemory>(
         new FakeSharedMemory(new char[size], size));
   }
 
  private:
   RTC_DISALLOW_COPY_AND_ASSIGN(FakeSharedMemoryFactory);
 };
 
-ACTION_P(SaveUniquePtrArg, dest) {
-  *dest = std::move(*arg1);
-}
-
 TEST_F(ScreenCapturerTest, GetScreenListAndSelectScreen) {
   webrtc::ScreenCapturer::ScreenList screens;
   EXPECT_TRUE(capturer_->GetScreenList(&screens));
   for (webrtc::ScreenCapturer::ScreenList::iterator it = screens.begin();
        it != screens.end(); ++it) {
     EXPECT_TRUE(capturer_->SelectScreen(it->id));
   }
 }
 
 TEST_F(ScreenCapturerTest, StartCapturer) {
@@ skipping 19 matching lines @@
 
   // Verify that the region contains whole screen.
   EXPECT_FALSE(frame->updated_region().is_empty());
   DesktopRegion::Iterator it(frame->updated_region());
   ASSERT_TRUE(!it.IsAtEnd());
   EXPECT_TRUE(it.rect().equals(DesktopRect::MakeSize(frame->size())));
   it.Advance();
   EXPECT_TRUE(it.IsAtEnd());
 }
 
+TEST_F(ScreenCapturerTest, CaptureUpdatedRegion) {
+  std::unique_ptr<ScreenPainter> painter = ScreenPainter::Create();
+  if (!painter || painter->DrawableRegion().is_empty()) {
+    LOG(LS_WARNING) << "No ScreenPainter implementation for current platform.";
+    return;
+  }
+  capturer_->Start(&callback_);
+
+  const DesktopRect anchor =
+      CalibrateScreenDrawerPosition(painter.get(), capturer_.get(), &callback_);
+  if (anchor.is_empty()) {
+    LOG(LS_WARNING) << "Failed to calibrate ScreenDrawer, it usually means "
+                       "ScreenDrawer cannot draw in ScreenCapturer reachable "
+                       "area.";
+    return;
+  }
+
+  painter->Clear();
+  ScreenPainter::Color color;
+  DesktopRect rect;
+  painter->DrawRandomColorRectangleIn(anchor.size(), &color, &rect);
+  rect.Translate(anchor.top_left());
+  painter->WaitForPendingPaintings();
+  std::unique_ptr<DesktopFrame> frame =
+      CaptureFrame(capturer_.get(), &callback_);
+  if (!frame) {
+    return;
+  }
+
+  // updated_region() should cover the painted area.
+  DesktopRegion updated_region(frame->updated_region());
+  updated_region.IntersectWith(rect);
+  ASSERT_TRUE(updated_region.Equals(DesktopRegion(rect)));
+
+  // Color in the |rect| should be |color|.
+  ExpectPixelsAreColoredBy(*frame, rect, color);
+}
+
 #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(
@@ skipping 60 matching lines @@
       std::unique_ptr<SharedMemoryFactory>(new FakeSharedMemoryFactory()));
   capturer_->Capture(DesktopRegion());
   ASSERT_TRUE(frame);
   ASSERT_TRUE(frame->shared_memory());
   EXPECT_EQ(frame->shared_memory()->id(), kTestSharedMemoryId);
 }
 
 #endif  // defined(WEBRTC_WIN)
 
 }  // namespace webrtc