Deflaky ScreenCapturerTest

webrtc/modules/desktop_capture/screen_drawer_linux.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 <fcntl.h>
+#include <sys/stat.h>
+#include <semaphore.h>
+
 #include <memory>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/desktop_capture/screen_drawer.h"
 #include "webrtc/modules/desktop_capture/x11/shared_x_display.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 
 namespace webrtc {
 
 namespace {
 
+static constexpr char kSemaphoreName[] =
+    "/global-screen-drawer-linux-54fe5552-8047-11e6-a725-3f429a5b4fb4";
+
+// A cross application lock to ensure only one ScreenDrawerLinux can be used at
+// a certain time.
+struct ScreenDrawerLock {
+  // Blocks current thread until a global lock is acquired.
+  ScreenDrawerLock();
+  // Releases the global lock acquired.
+  ~ScreenDrawerLock();
+
+ private:
+  sem_t* semaphore_;
+};
+
+ScreenDrawerLock::ScreenDrawerLock() {
+  semaphore_ =
+      sem_open(kSemaphoreName, O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO, 1);
+  sem_wait(semaphore_);
+}
+
+ScreenDrawerLock::~ScreenDrawerLock() {
+  sem_post(semaphore_);
+  sem_close(semaphore_);
+  // sem_unlink(kSemaphoreName);
+}
+
+std::unique_ptr<ScreenDrawerLock> g_screen_drawer_lock;
+
 // A ScreenDrawer implementation for X11.
 class ScreenDrawerLinux : public ScreenDrawer {
  public:
   ScreenDrawerLinux();
   ~ScreenDrawerLinux() override;
 
   // ScreenDrawer interface.
   DesktopRect DrawableRegion() override;
   void DrawRectangle(DesktopRect rect, RgbaColor color) override;
   void Clear() override;
   void WaitForPendingDraws() override;
+  bool MayDrawIncompleteShapes() override;
 
  private:
+  // Bring the window to the front, this can help to avoid the impact from other
+  // windows or shadow effect.
+  void BringToFront();
+
   rtc::scoped_refptr<SharedXDisplay> display_;
   int screen_num_;
   DesktopRect rect_;
   Window window_;
   GC context_;
   Colormap colormap_;
 };
 
 ScreenDrawerLinux::ScreenDrawerLinux() {
   display_ = SharedXDisplay::CreateDefault();
@@ skipping 28 matching lines @@
     RTC_DCHECK(false) << "Failed to get window position.";
   }
   // Some window manager does not allow a window to cover two or more monitors.
   // So if the window is on the first monitor of a two-monitor system, the
   // second half won't be able to show up without changing configurations of WM,
   // and its DrawableRegion() is not accurate.
   rect_ = DesktopRect::MakeLTRB(x, y, root_attributes.width,
                                 root_attributes.height);
   context_ = DefaultGC(display_->display(), screen_num_);
   colormap_ = DefaultColormap(display_->display(), screen_num_);
+  BringToFront();
   // Wait for window animations.
   SleepMs(200);
 }
 
 ScreenDrawerLinux::~ScreenDrawerLinux() {
   XUnmapWindow(display_->display(), window_);
   XDestroyWindow(display_->display(), window_);
+  g_screen_drawer_lock.reset();
 }
 
 DesktopRect ScreenDrawerLinux::DrawableRegion() {
   return rect_;
 }
 
 void ScreenDrawerLinux::DrawRectangle(DesktopRect rect, RgbaColor color) {
   rect.Translate(-rect_.left(), -rect_.top());
   XColor xcolor;
   // X11 does not support Alpha.
@@ skipping 11 matching lines @@
   XFlush(display_->display());
 }
 
 void ScreenDrawerLinux::Clear() {
   DrawRectangle(rect_, RgbaColor(0, 0, 0));
 }
 
 // TODO(zijiehe): Find the right signal from X11 to indicate the finish of all
 // pending paintings.
 void ScreenDrawerLinux::WaitForPendingDraws() {
+  BringToFront();
   SleepMs(50);
 }
 
+bool ScreenDrawerLinux::MayDrawIncompleteShapes() {
+  return true;
+}
+
+void ScreenDrawerLinux::BringToFront() {
+  XRaiseWindow(display_->display(), window_);
+}
+
 }  // namespace
 
 // static
 std::unique_ptr<ScreenDrawer> ScreenDrawer::Create() {
   if (SharedXDisplay::CreateDefault().get()) {
+    g_screen_drawer_lock.reset(new ScreenDrawerLock());
     return std::unique_ptr<ScreenDrawer>(new ScreenDrawerLinux());
   }
   return nullptr;
 }
 
 }  // namespace webrtc