Linux desktopCapture: fix the cursor position issue in Window sharing

webrtc/modules/desktop_capture/mouse_cursor_monitor_x11.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 <memory>
 
 #include "webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
 
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.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/mouse_cursor.h"
 #include "webrtc/modules/desktop_capture/x11/x_error_trap.h"
 
+namespace webrtc {
+
 namespace {
 
 // WindowCapturer returns window IDs of X11 windows with WM_STATE attribute.
 // These windows may not be immediate children of the root window, because
 // window managers may re-parent them to add decorations. However,
 // XQueryPointer() expects to be passed children of the root. This function
 // searches up the list of the windows to find the root child that corresponds
 // to |window|.
 Window GetTopLevelWindow(Display* display, Window window) {
   while (true) {
@@ skipping 12 matching lines @@
 
     if (parent == root)
       break;
 
     window = parent;
   }
 
   return window;
 }
 
+DesktopSize GetWindowSize(Display* display, Window window) {
+  XWindowAttributes attributes;
+  {
+    XErrorTrap error_trap(display);
+    if (!XGetWindowAttributes(display, window, &attributes) ||
+        error_trap.GetLastErrorAndDisable() != 0) {
+      return DesktopSize(0, 0);

[Sergey Ulanov, 2017/05/19 20:36:03]

DesktopSize(); Don't need the zeros

[braveyao1, 2017/05/19 22:38:59]

Done.

+    }
+  }
+
+  return DesktopSize(attributes.width, attributes.height);
+}
+
+// As the comments to |GetTopLevelWindow()| above states, in window capture,

[Sergey Ulanov, 2017/05/19 20:36:03]

nit: || around name of a function are not necessary. Parentheses at the end make
it clear that this is a reference to a function

[braveyao1, 2017/05/19 22:38:59]

Done.

+// the captured frame is in the coordinates of the input |window|, while the
+// captured cursor position is in the coordinates of its |parent| window.
+// And these two coordinates are not always same. The |parent| window may have
+// decorations added, including the caption bar on top of the window and the
+// shadow and border around them. The offset needs to be compensated later.
+DesktopVector GetCursorPostionOffset(Display* display,
+                                     Window parent,
+                                     Window children) {

[Sergey Ulanov, 2017/05/19 20:36:03]

s/children/child/
'children' is plural

[braveyao1, 2017/05/19 22:38:59]

Done.

+  DesktopSize parent_size = GetWindowSize(display, parent);
+  DesktopSize children_size = GetWindowSize(display, children);
+
+  if (parent_size.is_empty() || children_size.is_empty()) {
+    return DesktopVector(0, 0);
+  }
+  // The |x_offset| is the thickness of the shadow and border added around.
+  // The |y_offset| doesn't include the shadow and border added at the bottom.
+  int x_offset = (parent_size.width() - children_size.width()) / 2;

[Sergey Ulanov, 2017/05/19 20:36:03]

This assumes that the border has the same width on left and right.  I don't
think it's safe to make this assumption. Is it not possible to directly get
position the child window relative to parent? XTranslateCoordinates() may be
useful here.

[braveyao1, 2017/05/19 22:38:59]

Done.

+  int y_offset = parent_size.height() - children_size.height() - x_offset;

[Sergey Ulanov, 2017/05/19 20:36:03]

This also assumes that border at the bottom is the same as on left and right. I
don't think this is a safe assumption.

[braveyao1, 2017/05/19 22:38:59]

Done.

+
+  return DesktopVector(x_offset, y_offset);
+}
+
 }  // namespace
 
-namespace webrtc {
-
 class MouseCursorMonitorX11 : public MouseCursorMonitor,
                               public SharedXDisplay::XEventHandler {
  public:
-  MouseCursorMonitorX11(const DesktopCaptureOptions& options, Window window);
+  MouseCursorMonitorX11(const DesktopCaptureOptions& options,
+                        Window window,
+                        DesktopVector offset);
   ~MouseCursorMonitorX11() override;
 
   void Init(Callback* callback, Mode mode) override;
   void Capture() override;
 
  private:
   // SharedXDisplay::XEventHandler interface.
   bool HandleXEvent(const XEvent& event) override;
 
   Display* display() { return x_display_->display(); }
 
   // Captures current cursor shape and stores it in |cursor_shape_|.
   void CaptureCursor();
 
   rtc::scoped_refptr<SharedXDisplay> x_display_;
   Callback* callback_;
   Mode mode_;
   Window window_;
+  DesktopVector offset_;
 
   bool have_xfixes_;
   int xfixes_event_base_;
   int xfixes_error_base_;
 
   std::unique_ptr<MouseCursor> cursor_shape_;
 };
 
 MouseCursorMonitorX11::MouseCursorMonitorX11(
     const DesktopCaptureOptions& options,
-    Window window)
+    Window window,
+    DesktopVector offset)
     : x_display_(options.x_display()),
       callback_(NULL),
       mode_(SHAPE_AND_POSITION),
       window_(window),
+      offset_(offset),
       have_xfixes_(false),
       xfixes_event_base_(-1),
       xfixes_error_base_(-1) {
   // Set a default initial cursor shape in case XFixes is not present.
   const int kSize = 5;
   std::unique_ptr<DesktopFrame> default_cursor(
       new BasicDesktopFrame(DesktopSize(kSize, kSize)));
   const uint8_t pixels[kSize * kSize] = {
     0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0xff, 0xff, 0xff, 0x00,
@@ skipping 70 matching lines @@
     if (!result || error_trap.GetLastErrorAndDisable() != 0) {
       state = OUTSIDE;
     } else {
       // In screen mode (window_ == root_window) the mouse is always inside.
       // XQueryPointer() sets |child_window| to None if the cursor is outside
       // |window_|.
       state =
           (window_ == root_window || child_window != None) ? INSIDE : OUTSIDE;
     }
 
-    callback_->OnMouseCursorPosition(state,
-                                     webrtc::DesktopVector(win_x, win_y));
+    callback_->OnMouseCursorPosition(
+        state, DesktopVector(win_x, win_y).subtract(offset_));
   }
 }
 
 bool MouseCursorMonitorX11::HandleXEvent(const XEvent& event) {
   if (have_xfixes_ && event.type == xfixes_event_base_ + XFixesCursorNotify) {
     const XFixesCursorNotifyEvent* cursor_event =
         reinterpret_cast<const XFixesCursorNotifyEvent*>(&event);
     if (cursor_event->subtype == XFixesDisplayCursorNotify) {
       CaptureCursor();
     }
@@ skipping 31 matching lines @@
   XFree(img);
 
   cursor_shape_.reset(new MouseCursor(image.release(), hotspot));
 }
 
 // static
 MouseCursorMonitor* MouseCursorMonitor::CreateForWindow(
     const DesktopCaptureOptions& options, WindowId window) {
   if (!options.x_display())
     return NULL;
-  window = GetTopLevelWindow(options.x_display()->display(), window);
-  if (window == None)
+  Window parent = GetTopLevelWindow(options.x_display()->display(), window);
+  if (parent == None)
     return NULL;
-  return new MouseCursorMonitorX11(options, window);
+
+  DesktopVector offset =
+      GetCursorPostionOffset(options.x_display()->display(), parent, window);
+  return new MouseCursorMonitorX11(options, parent, offset);
 }
 
 MouseCursorMonitor* MouseCursorMonitor::CreateForScreen(
     const DesktopCaptureOptions& options,
     ScreenId screen) {
   if (!options.x_display())
     return NULL;
+
   return new MouseCursorMonitorX11(
-      options, DefaultRootWindow(options.x_display()->display()));
+      options, DefaultRootWindow(options.x_display()->display()),
+      DesktopVector(0, 0));
 }
 
 }  // namespace webrtc