[WebRTC] A real ScreenCapturer test

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 <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 {
 
 // A ScreenDrawer implementation for X11.
 class ScreenDrawerLinux : public ScreenDrawer {
  public:
   ScreenDrawerLinux();
   ~ScreenDrawerLinux() override;
 
   // ScreenDrawer interface.
   DesktopRect DrawableRegion() override;
-  void DrawRectangle(DesktopRect rect, uint32_t rgba) override;
+  void DrawRectangle(DesktopRect rect, Color color) override;
   void Clear() override;
+  void WaitForPendingDraws() override;
 
  private:
   rtc::scoped_refptr<SharedXDisplay> display_;
-  Screen* screen_;
   int screen_num_;
   DesktopRect rect_;
   Window window_;
   GC context_;
   Colormap colormap_;
 };
 
 ScreenDrawerLinux::ScreenDrawerLinux() {
   display_ = SharedXDisplay::CreateDefault();
   RTC_CHECK(display_.get());
-  screen_ = DefaultScreenOfDisplay(display_->display());
-  RTC_CHECK(screen_);
   screen_num_ = DefaultScreen(display_->display());
-  rect_ = DesktopRect::MakeWH(screen_->width, screen_->height);
-  window_ = XCreateSimpleWindow(display_->display(),
-                                RootWindow(display_->display(), screen_num_), 0,
-                                0, rect_.width(), rect_.height(), 0,
-                                BlackPixel(display_->display(), screen_num_),
-                                BlackPixel(display_->display(), screen_num_));
+  XWindowAttributes root_attributes;
+  if (!XGetWindowAttributes(display_->display(),
+                            RootWindow(display_->display(), screen_num_),
+                            &root_attributes)) {
+    RTC_DCHECK(false) << "Failed to get root window size.";
+  }
+  window_ = XCreateSimpleWindow(
+      display_->display(), RootWindow(display_->display(), screen_num_), 0, 0,
+      root_attributes.width, root_attributes.height, 0,
+      BlackPixel(display_->display(), screen_num_),
+      BlackPixel(display_->display(), screen_num_));
   XSelectInput(display_->display(), window_, StructureNotifyMask);
   XMapWindow(display_->display(), window_);
   while (true) {
     XEvent event;
     XNextEvent(display_->display(), &event);
     if (event.type == MapNotify) {
       break;
     }
   }
   XFlush(display_->display());
+  Window child;
+  int x, y;
+  if (!XTranslateCoordinates(display_->display(), window_,
+                             RootWindow(display_->display(), screen_num_), 0, 0,
+                             &x, &y, &child)) {
+    RTC_DCHECK(false) << "Failed to get window position.";
+  }
+  // In two monitor system, if this window is on the first monitor, part of the
+  // DrawableRegion() may be covered by the root window on the second monitor.
+  rect_ = DesktopRect::MakeLTRB(x, y, root_attributes.width,
+                                root_attributes.height);
   context_ = DefaultGC(display_->display(), screen_num_);
   colormap_ = DefaultColormap(display_->display(), screen_num_);
+  // Wait for window animations.
+  SleepMs(200);
 }
 
 ScreenDrawerLinux::~ScreenDrawerLinux() {
   XUnmapWindow(display_->display(), window_);
   XDestroyWindow(display_->display(), window_);
 }
 
 DesktopRect ScreenDrawerLinux::DrawableRegion() {
   return rect_;
 }
 
-void ScreenDrawerLinux::DrawRectangle(DesktopRect rect, uint32_t rgba) {
-  int r = (rgba & 0xff00) >> 8;
-  int g = (rgba & 0xff0000) >> 16;
-  int b = (rgba & 0xff000000) >> 24;
+void ScreenDrawerLinux::DrawRectangle(DesktopRect rect, Color color) {
+  rect.Translate(-rect_.left(), -rect_.top());
+  XColor xcolor;
   // X11 does not support Alpha.
-  XColor color;
   // X11 uses 16 bits for each primary color.
-  color.red = r * 256;
-  color.green = g * 256;
-  color.blue = b * 256;
-  color.flags = DoRed | DoGreen | DoBlue;
-  XAllocColor(display_->display(), colormap_, &color);
-  XSetForeground(display_->display(), context_, color.pixel);
+  xcolor.red = color.red() * 256 + color.red();
+  xcolor.green = color.green() * 256 + color.green();
+  xcolor.blue = color.blue() * 256 + color.blue();
+  xcolor.flags = DoRed | DoGreen | DoBlue;
+  XAllocColor(display_->display(), colormap_, &xcolor);
+  XSetForeground(display_->display(), context_, xcolor.pixel);
   XFillRectangle(display_->display(), window_, context_, rect.left(),
                  rect.top(), rect.width(), rect.height());
   XFlush(display_->display());
 }
 
 void ScreenDrawerLinux::Clear() {
-  DrawRectangle(DrawableRegion(), 0);
+  DrawRectangle(rect_, Color(0, 0, 0));
+}
+
+// TODO(zijiehe): Find the right signal from X11 to indicate the finish of all
+// pending paintings.
+void ScreenDrawerLinux::WaitForPendingDraws() {
+  SleepMs(50);
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<ScreenDrawer> ScreenDrawer::Create() {
-  return std::unique_ptr<ScreenDrawer>(new ScreenDrawerLinux());
+  if (SharedXDisplay::CreateDefault().get()) {
+    return std::unique_ptr<ScreenDrawer>(new ScreenDrawerLinux());
+  } else {
+    return nullptr;
+  }
 }
 
 }  // namespace webrtc