screen_drawer_unittest.cc (5563B)
1 /* 2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "modules/desktop_capture/screen_drawer.h" 12 13 #include <atomic> 14 #include <cstdint> 15 #include <memory> 16 17 #include "api/function_view.h" 18 #include "modules/desktop_capture/desktop_geometry.h" 19 #include "modules/desktop_capture/rgba_color.h" 20 #include "rtc_base/logging.h" 21 #include "rtc_base/platform_thread.h" 22 #include "rtc_base/random.h" 23 #include "rtc_base/thread.h" 24 #include "rtc_base/time_utils.h" 25 #include "test/gtest.h" 26 27 #if defined(WEBRTC_POSIX) 28 #include "modules/desktop_capture/screen_drawer_lock_posix.h" 29 #endif 30 31 namespace webrtc { 32 33 namespace { 34 35 void TestScreenDrawerLock( 36 FunctionView<std::unique_ptr<ScreenDrawerLock>()> ctor) { 37 constexpr int kLockDurationMs = 100; 38 39 std::atomic<bool> created(false); 40 std::atomic<bool> ready(false); 41 42 class Task { 43 public: 44 Task(std::atomic<bool>* created, 45 const std::atomic<bool>& ready, 46 FunctionView<std::unique_ptr<ScreenDrawerLock>()> ctor) 47 : created_(created), ready_(ready), ctor_(ctor) {} 48 49 ~Task() = default; 50 51 void RunTask() { 52 std::unique_ptr<ScreenDrawerLock> lock = ctor_(); 53 ASSERT_TRUE(!!lock); 54 created_->store(true); 55 // Wait for the main thread to get the signal of created_. 56 while (!ready_.load()) { 57 Thread::SleepMs(1); 58 } 59 // At this point, main thread should begin to create a second lock. Though 60 // it's still possible the second lock won't be created before the 61 // following sleep has been finished, the possibility will be 62 // significantly reduced. 63 const int64_t current_ms = TimeMillis(); 64 // SleepMs() may return early. See 65 // https://cs.chromium.org/chromium/src/third_party/webrtc/system_wrappers/include/sleep.h?rcl=4a604c80cecce18aff6fc5e16296d04675312d83&l=20 66 // But we need to ensure at least 100 ms has been passed before unlocking 67 // `lock`. 68 while (TimeMillis() - current_ms < kLockDurationMs) { 69 Thread::SleepMs(kLockDurationMs - (TimeMillis() - current_ms)); 70 } 71 } 72 73 private: 74 std::atomic<bool>* const created_; 75 const std::atomic<bool>& ready_; 76 const FunctionView<std::unique_ptr<ScreenDrawerLock>()> ctor_; 77 } task(&created, ready, ctor); 78 79 auto lock_thread = 80 PlatformThread::SpawnJoinable([&task] { task.RunTask(); }, "lock_thread"); 81 82 // Wait for the first lock in Task::RunTask() to be created. 83 // TODO(zijiehe): Find a better solution to wait for the creation of the first 84 // lock. See 85 // https://chromium-review.googlesource.com/c/607688/13/webrtc/modules/desktop_capture/screen_drawer_unittest.cc 86 while (!created.load()) { 87 Thread::SleepMs(1); 88 } 89 90 const int64_t start_ms = TimeMillis(); 91 ready.store(true); 92 // This is unlikely to fail, but just in case current thread is too laggy and 93 // cause the SleepMs() in RunTask() to finish before we creating another lock. 94 ASSERT_GT(kLockDurationMs, TimeMillis() - start_ms); 95 ctor(); 96 ASSERT_LE(kLockDurationMs, TimeMillis() - start_ms); 97 } 98 99 } // namespace 100 101 // These are a set of manual test cases, as we do not have an automatical way to 102 // detect whether a ScreenDrawer on a certain platform works well without 103 // ScreenCapturer(s). So you may execute these test cases with 104 // --gtest_also_run_disabled_tests --gtest_filter=ScreenDrawerTest.*. 105 TEST(ScreenDrawerTest, DISABLED_DrawRectangles) { 106 std::unique_ptr<ScreenDrawer> drawer = ScreenDrawer::Create(); 107 if (!drawer) { 108 RTC_LOG(LS_WARNING) 109 << "No ScreenDrawer implementation for current platform."; 110 return; 111 } 112 113 if (drawer->DrawableRegion().is_empty()) { 114 RTC_LOG(LS_WARNING) 115 << "ScreenDrawer of current platform does not provide a " 116 "non-empty DrawableRegion()."; 117 return; 118 } 119 120 DesktopRect rect = drawer->DrawableRegion(); 121 Random random(TimeMicros()); 122 for (int i = 0; i < 100; i++) { 123 // Make sure we at least draw one pixel. 124 int left = random.Rand(rect.left(), rect.right() - 2); 125 int top = random.Rand(rect.top(), rect.bottom() - 2); 126 drawer->DrawRectangle( 127 DesktopRect::MakeLTRB(left, top, random.Rand(left + 1, rect.right()), 128 random.Rand(top + 1, rect.bottom())), 129 RgbaColor(random.Rand<uint8_t>(), random.Rand<uint8_t>(), 130 random.Rand<uint8_t>(), random.Rand<uint8_t>())); 131 132 if (i == 50) { 133 Thread::SleepMs(10000); 134 } 135 } 136 137 Thread::SleepMs(10000); 138 } 139 140 #if defined(THREAD_SANITIZER) // bugs.webrtc.org/10019 141 #define MAYBE_TwoScreenDrawerLocks DISABLED_TwoScreenDrawerLocks 142 #else 143 #define MAYBE_TwoScreenDrawerLocks TwoScreenDrawerLocks 144 #endif 145 TEST(ScreenDrawerTest, MAYBE_TwoScreenDrawerLocks) { 146 #if defined(WEBRTC_POSIX) 147 // ScreenDrawerLockPosix won't be able to unlink the named semaphore. So use a 148 // different semaphore name here to avoid deadlock. 149 const char* semaphore_name = "GSDL8784541a812011e788ff67427b"; 150 ScreenDrawerLockPosix::Unlink(semaphore_name); 151 152 TestScreenDrawerLock([semaphore_name]() { 153 return std::make_unique<ScreenDrawerLockPosix>(semaphore_name); 154 }); 155 #elif defined(WEBRTC_WIN) 156 TestScreenDrawerLock([]() { return ScreenDrawerLock::Create(); }); 157 #endif 158 } 159 160 } // namespace webrtc