ui/aura/window_tree_host_x11.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/aura/window_tree_host_x11.h"
   6
   7 #include <strings.h>
   8 #include <X11/cursorfont.h>
   9 #include <X11/extensions/XInput2.h>
  10 #include <X11/extensions/Xrandr.h>
  11 #include <X11/Xatom.h>
  12 #include <X11/Xcursor/Xcursor.h>
  13 #include <X11/Xlib.h>
  14
  15 #include <algorithm>
  16 #include <limits>
  17 #include <string>
  18
  19 #include "base/basictypes.h"
  20 #include "base/command_line.h"
  21 #include "base/debug/trace_event.h"
  22 #include "base/stl_util.h"
  23 #include "base/strings/string_number_conversions.h"
  24 #include "base/strings/string_util.h"
  25 #include "base/strings/stringprintf.h"
  26 #include "base/sys_info.h"
  27 #include "ui/aura/client/cursor_client.h"
  28 #include "ui/aura/env.h"
  29 #include "ui/aura/window.h"
  30 #include "ui/aura/window_event_dispatcher.h"
  31 #include "ui/base/cursor/cursor.h"
  32 #include "ui/base/ui_base_switches.h"
  33 #include "ui/base/view_prop.h"
  34 #include "ui/base/x/x11_util.h"
  35 #include "ui/compositor/compositor.h"
  36 #include "ui/compositor/dip_util.h"
  37 #include "ui/compositor/layer.h"
  38 #include "ui/events/devices/x11/device_data_manager_x11.h"
  39 #include "ui/events/devices/x11/device_list_cache_x11.h"
  40 #include "ui/events/devices/x11/touch_factory_x11.h"
  41 #include "ui/events/event.h"
  42 #include "ui/events/event_switches.h"
  43 #include "ui/events/event_utils.h"
  44 #include "ui/events/keycodes/keyboard_codes.h"
  45 #include "ui/events/platform/platform_event_observer.h"
  46 #include "ui/events/platform/x11/x11_event_source.h"
  47 #include "ui/gfx/screen.h"
  48
  49 using std::max;
  50 using std::min;
  51
  52 namespace aura {
  53
  54 namespace {
  55
  56 const char* kAtomsToCache[] = {
  57   "WM_DELETE_WINDOW",
  58   "_NET_WM_PING",
  59   "_NET_WM_PID",
  60   NULL
  61 };
  62
  63 ::Window FindEventTarget(const base::NativeEvent& xev) {
  64   ::Window target = xev->xany.window;
  65   if (xev->type == GenericEvent)
  66     target = static_cast<XIDeviceEvent*>(xev->xcookie.data)->event;
  67   return target;
  68 }
  69
  70 void SelectXInput2EventsForRootWindow(XDisplay* display, ::Window root_window) {
  71   CHECK(ui::IsXInput2Available());
  72   unsigned char mask[XIMaskLen(XI_LASTEVENT)] = {};
  73   memset(mask, 0, sizeof(mask));
  74
  75   XISetMask(mask, XI_HierarchyChanged);
  76
  77   XIEventMask evmask;
  78   evmask.deviceid = XIAllDevices;
  79   evmask.mask_len = sizeof(mask);
  80   evmask.mask = mask;
  81   XISelectEvents(display, root_window, &evmask, 1);
  82
  83 #if defined(OS_CHROMEOS)
  84   if (base::SysInfo::IsRunningOnChromeOS()) {
  85     // It is necessary to listen for touch events on the root window for proper
  86     // touch event calibration on Chrome OS, but this is not currently necessary
  87     // on the desktop. This seems to fail in some cases (e.g. when logging
  88     // in incognito). So select for non-touch events first, and then select for
  89     // touch-events (but keep the other events in the mask, i.e. do not memset
  90     // |mask| back to 0).
  91     // TODO(sad): Figure out why this happens. http://crbug.com/153976
  92     XISetMask(mask, XI_TouchBegin);
  93     XISetMask(mask, XI_TouchUpdate);
  94     XISetMask(mask, XI_TouchEnd);
  95     XISelectEvents(display, root_window, &evmask, 1);
  96   }
  97 #endif
  98 }
  99
 100 bool default_override_redirect = false;
 101
 102 }  // namespace
 103
 104 namespace internal {
 105
 106 // TODO(miletus) : Move this into DeviceDataManager.
 107 // Accomplishes 2 tasks concerning touch event calibration:
 108 // 1. Being a message-pump observer,
 109 //    routes all the touch events to the X root window,
 110 //    where they can be calibrated later.
 111 // 2. Has the Calibrate method that does the actual bezel calibration,
 112 //    when invoked from X root window's event dispatcher.
 113 class TouchEventCalibrate : public ui::PlatformEventObserver {
 114  public:
 115   TouchEventCalibrate() : left_(0), right_(0), top_(0), bottom_(0) {
 116     if (ui::PlatformEventSource::GetInstance())
 117       ui::PlatformEventSource::GetInstance()->AddPlatformEventObserver(this);
 118 #if defined(USE_XI2_MT)
 119     std::vector<std::string> parts;
 120     if (Tokenize(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 121                      switches::kTouchCalibration),
 122                  ",",
 123                  &parts) >= 4) {
 124       if (!base::StringToInt(parts[0], &left_))
 125         DLOG(ERROR) << "Incorrect left border calibration value passed.";
 126       if (!base::StringToInt(parts[1], &right_))
 127         DLOG(ERROR) << "Incorrect right border calibration value passed.";
 128       if (!base::StringToInt(parts[2], &top_))
 129         DLOG(ERROR) << "Incorrect top border calibration value passed.";
 130       if (!base::StringToInt(parts[3], &bottom_))
 131         DLOG(ERROR) << "Incorrect bottom border calibration value passed.";
 132     }
 133 #endif  // defined(USE_XI2_MT)
 134   }
 135
 136   ~TouchEventCalibrate() override {
 137     if (ui::PlatformEventSource::GetInstance())
 138       ui::PlatformEventSource::GetInstance()->RemovePlatformEventObserver(this);
 139   }
 140
 141   // Modify the location of the |event|,
 142   // expanding it from |bounds| to (|bounds| + bezels).
 143   // Required when touchscreen is bigger than screen (i.e. has bezels),
 144   // because we receive events in touchscreen coordinates,
 145   // which need to be expanded when converting to screen coordinates,
 146   // so that location on bezels will be outside of screen area.
 147   void Calibrate(ui::TouchEvent* event, const gfx::Rect& bounds) {
 148 #if defined(USE_XI2_MT)
 149     int x = event->x();
 150     int y = event->y();
 151
 152     if (!left_ && !right_ && !top_ && !bottom_)
 153       return;
 154
 155     const int resolution_x = bounds.width();
 156     const int resolution_y = bounds.height();
 157     // The "grace area" (10% in this case) is to make it easier for the user to
 158     // navigate to the corner.
 159     const double kGraceAreaFraction = 0.1;
 160     if (left_ || right_) {
 161       // Offset the x position to the real
 162       x -= left_;
 163       // Check if we are in the grace area of the left side.
 164       // Note: We might not want to do this when the gesture is locked?
 165       if (x < 0 && x > -left_ * kGraceAreaFraction)
 166         x = 0;
 167       // Check if we are in the grace area of the right side.
 168       // Note: We might not want to do this when the gesture is locked?
 169       if (x > resolution_x - left_ &&
 170           x < resolution_x - left_ + right_ * kGraceAreaFraction)
 171         x = resolution_x - left_;
 172       // Scale the screen area back to the full resolution of the screen.
 173       x = (x * resolution_x) / (resolution_x - (right_ + left_));
 174     }
 175     if (top_ || bottom_) {
 176       // When there is a top bezel we add our border,
 177       y -= top_;
 178
 179       // Check if we are in the grace area of the top side.
 180       // Note: We might not want to do this when the gesture is locked?
 181       if (y < 0 && y > -top_ * kGraceAreaFraction)
 182         y = 0;
 183
 184       // Check if we are in the grace area of the bottom side.
 185       // Note: We might not want to do this when the gesture is locked?
 186       if (y > resolution_y - top_ &&
 187           y < resolution_y - top_ + bottom_ * kGraceAreaFraction)
 188         y = resolution_y - top_;
 189       // Scale the screen area back to the full resolution of the screen.
 190       y = (y * resolution_y) / (resolution_y - (bottom_ + top_));
 191     }
 192
 193     // Set the modified coordinate back to the event.
 194     if (event->root_location() == event->location()) {
 195       // Usually those will be equal,
 196       // if not, I am not sure what the correct value should be.
 197       event->set_root_location(gfx::Point(x, y));
 198     }
 199     event->set_location(gfx::Point(x, y));
 200 #endif  // defined(USE_XI2_MT)
 201   }
 202
 203  private:
 204   // ui::PlatformEventObserver:
 205   void WillProcessEvent(const ui::PlatformEvent& event) override {
 206 #if defined(USE_XI2_MT)
 207     if (event->type == GenericEvent &&
 208         (event->xgeneric.evtype == XI_TouchBegin ||
 209          event->xgeneric.evtype == XI_TouchUpdate ||
 210          event->xgeneric.evtype == XI_TouchEnd)) {
 211       XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(event->xcookie.data);
 212       xievent->event = xievent->root;
 213       xievent->event_x = xievent->root_x;
 214       xievent->event_y = xievent->root_y;
 215     }
 216 #endif  // defined(USE_XI2_MT)
 217   }
 218
 219   void DidProcessEvent(const ui::PlatformEvent& event) override {}
 220
 221   // The difference in screen's native resolution pixels between
 222   // the border of the touchscreen and the border of the screen,
 223   // aka bezel sizes.
 224   int left_;
 225   int right_;
 226   int top_;
 227   int bottom_;
 228
 229   DISALLOW_COPY_AND_ASSIGN(TouchEventCalibrate);
 230 };
 231
 232 }  // namespace internal
 233
 234 ////////////////////////////////////////////////////////////////////////////////
 235 // WindowTreeHostX11
 236
 237 WindowTreeHostX11::WindowTreeHostX11(const gfx::Rect& bounds)
 238     : xdisplay_(gfx::GetXDisplay()),
 239       xwindow_(0),
 240       x_root_window_(DefaultRootWindow(xdisplay_)),
 241       current_cursor_(ui::kCursorNull),
 242       window_mapped_(false),
 243       bounds_(bounds),
 244       touch_calibrate_(new internal::TouchEventCalibrate),
 245       atom_cache_(xdisplay_, kAtomsToCache) {
 246   XSetWindowAttributes swa;
 247   memset(&swa, 0, sizeof(swa));
 248   swa.background_pixmap = None;
 249   swa.override_redirect = default_override_redirect;
 250   xwindow_ = XCreateWindow(
 251       xdisplay_, x_root_window_,
 252       bounds.x(), bounds.y(), bounds.width(), bounds.height(),
 253       0,               // border width
 254       CopyFromParent,  // depth
 255       InputOutput,
 256       CopyFromParent,  // visual
 257       CWBackPixmap | CWOverrideRedirect,
 258       &swa);
 259   if (ui::PlatformEventSource::GetInstance())
 260     ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
 261
 262   long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
 263                     KeyPressMask | KeyReleaseMask |
 264                     EnterWindowMask | LeaveWindowMask |
 265                     ExposureMask | VisibilityChangeMask |
 266                     StructureNotifyMask | PropertyChangeMask |
 267                     PointerMotionMask;
 268   XSelectInput(xdisplay_, xwindow_, event_mask);
 269   XFlush(xdisplay_);
 270
 271   if (ui::IsXInput2Available()) {
 272     ui::TouchFactory::GetInstance()->SetupXI2ForXWindow(xwindow_);
 273     SelectXInput2EventsForRootWindow(xdisplay_, x_root_window_);
 274   }
 275
 276   // TODO(erg): We currently only request window deletion events. We also
 277   // should listen for activation events and anything else that GTK+ listens
 278   // for, and do something useful.
 279   ::Atom protocols[2];
 280   protocols[0] = atom_cache_.GetAtom("WM_DELETE_WINDOW");
 281   protocols[1] = atom_cache_.GetAtom("_NET_WM_PING");
 282   XSetWMProtocols(xdisplay_, xwindow_, protocols, 2);
 283
 284   // We need a WM_CLIENT_MACHINE and WM_LOCALE_NAME value so we integrate with
 285   // the desktop environment.
 286   XSetWMProperties(xdisplay_, xwindow_, NULL, NULL, NULL, 0, NULL, NULL, NULL);
 287
 288   // Likewise, the X server needs to know this window's pid so it knows which
 289   // program to kill if the window hangs.
 290   // XChangeProperty() expects "pid" to be long.
 291   COMPILE_ASSERT(sizeof(long) >= sizeof(pid_t), pid_t_bigger_than_long);
 292   long pid = getpid();
 293   XChangeProperty(xdisplay_,
 294                   xwindow_,
 295                   atom_cache_.GetAtom("_NET_WM_PID"),
 296                   XA_CARDINAL,
 297                   32,
 298                   PropModeReplace,
 299                   reinterpret_cast<unsigned char*>(&pid), 1);
 300
 301   // Allow subclasses to create and cache additional atoms.
 302   atom_cache_.allow_uncached_atoms();
 303
 304   XRRSelectInput(xdisplay_, x_root_window_,
 305                  RRScreenChangeNotifyMask | RROutputChangeNotifyMask);
 306   CreateCompositor(GetAcceleratedWidget());
 307 }
 308
 309 WindowTreeHostX11::~WindowTreeHostX11() {
 310   if (ui::PlatformEventSource::GetInstance())
 311     ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
 312
 313   DestroyCompositor();
 314   DestroyDispatcher();
 315   XDestroyWindow(xdisplay_, xwindow_);
 316 }
 317
 318 bool WindowTreeHostX11::CanDispatchEvent(const ui::PlatformEvent& event) {
 319   ::Window target = FindEventTarget(event);
 320   return target == xwindow_ || target == x_root_window_;
 321 }
 322
 323 uint32_t WindowTreeHostX11::DispatchEvent(const ui::PlatformEvent& event) {
 324   XEvent* xev = event;
 325   if (FindEventTarget(xev) == x_root_window_) {
 326     if (xev->type == GenericEvent)
 327       DispatchXI2Event(xev);
 328     return ui::POST_DISPATCH_NONE;
 329   }
 330
 331   if (xev->type == MotionNotify) {
 332     // Discard all but the most recent motion event that targets the same
 333     // window with unchanged state.
 334     XEvent last_event;
 335     while (XPending(xev->xany.display)) {
 336       XEvent next_event;
 337       XPeekEvent(xev->xany.display, &next_event);
 338       if (next_event.type == MotionNotify &&
 339           next_event.xmotion.window == xev->xmotion.window &&
 340           next_event.xmotion.subwindow == xev->xmotion.subwindow &&
 341           next_event.xmotion.state == xev->xmotion.state) {
 342         XNextEvent(xev->xany.display, &last_event);
 343         xev = &last_event;
 344       } else {
 345         break;
 346       }
 347     }
 348   }
 349
 350   if ((xev->type == EnterNotify || xev->type == LeaveNotify) &&
 351       xev->xcrossing.detail == NotifyInferior) {
 352     // Ignore EventNotify and LeaveNotify  events from children of |xwindow_|.
 353     // NativeViewGLSurfaceGLX adds a child to |xwindow_|.
 354     // TODO(pkotwicz|tdanderson): Figure out whether the suppression is
 355     // necessary. crbug.com/385716
 356     return ui::POST_DISPATCH_STOP_PROPAGATION;
 357   }
 358
 359   if (xev->type == EnterNotify ||
 360       xev->type == LeaveNotify ||
 361       xev->type == KeyPress ||
 362       xev->type == KeyRelease ||
 363       xev->type == ButtonPress ||
 364       xev->type == ButtonRelease ||
 365       xev->type == MotionNotify) {
 366     switch (ui::EventTypeFromNative(xev)) {
 367       case ui::ET_KEY_PRESSED:
 368       case ui::ET_KEY_RELEASED: {
 369         ui::KeyEvent keydown_event(xev);
 370         SendEventToProcessor(&keydown_event);
 371         break;
 372       }
 373       case ui::ET_MOUSE_MOVED:
 374       case ui::ET_MOUSE_DRAGGED:
 375       case ui::ET_MOUSE_ENTERED:
 376       case ui::ET_MOUSE_EXITED:
 377       case ui::ET_MOUSE_PRESSED:
 378       case ui::ET_MOUSE_RELEASED: {
 379         ui::MouseEvent mouse_event(xev);
 380         if (xev->type == EnterNotify) {
 381           aura::Window* root_window = window();
 382           client::CursorClient* cursor_client =
 383               client::GetCursorClient(root_window);
 384           if (cursor_client) {
 385             const gfx::Display display = gfx::Screen::GetScreenFor(
 386                 root_window)->GetDisplayNearestWindow(root_window);
 387             cursor_client->SetDisplay(display);
 388           }
 389           // EnterNotify creates ET_MOUSE_MOVE. Mark as synthesized as this is
 390           // not a real mouse move event.
 391           mouse_event.set_flags(mouse_event.flags() | ui::EF_IS_SYNTHESIZED);
 392         }
 393
 394         TranslateAndDispatchLocatedEvent(&mouse_event);
 395         break;
 396       }
 397       case ui::ET_MOUSEWHEEL: {
 398         ui::MouseWheelEvent mouseev(xev);
 399         TranslateAndDispatchLocatedEvent(&mouseev);
 400         break;
 401       }
 402       case ui::ET_UNKNOWN:
 403         // No event is created for X11-release events for mouse-wheel buttons.
 404         break;
 405       default:
 406          NOTREACHED();
 407     }
 408     return ui::POST_DISPATCH_STOP_PROPAGATION;
 409   }
 410
 411   switch (xev->type) {
 412     case Expose: {
 413       gfx::Rect damage_rect(xev->xexpose.x, xev->xexpose.y,
 414                             xev->xexpose.width, xev->xexpose.height);
 415       compositor()->ScheduleRedrawRect(damage_rect);
 416       break;
 417     }
 418     case FocusOut:
 419       if (xev->xfocus.mode != NotifyGrab)
 420         OnHostLostWindowCapture();
 421       break;
 422     case ConfigureNotify: {
 423       DCHECK_EQ(xwindow_, xev->xconfigure.event);
 424       DCHECK_EQ(xwindow_, xev->xconfigure.window);
 425       // It's possible that the X window may be resized by some other means
 426       // than from within aura (e.g. the X window manager can change the
 427       // size). Make sure the root window size is maintained properly.
 428       gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
 429           xev->xconfigure.width, xev->xconfigure.height);
 430       bool size_changed = bounds_.size() != bounds.size();
 431       bool origin_changed = bounds_.origin() != bounds.origin();
 432       bounds_ = bounds;
 433       OnConfigureNotify();
 434       if (size_changed)
 435         OnHostResized(bounds.size());
 436       if (origin_changed)
 437         OnHostMoved(bounds_.origin());
 438       break;
 439     }
 440     case GenericEvent:
 441       DispatchXI2Event(xev);
 442       break;
 443     case ClientMessage: {
 444       Atom message_type = static_cast<Atom>(xev->xclient.data.l[0]);
 445       if (message_type == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
 446         // We have received a close message from the window manager.
 447         OnHostCloseRequested();
 448       } else if (message_type == atom_cache_.GetAtom("_NET_WM_PING")) {
 449         XEvent reply_event = *xev;
 450         reply_event.xclient.window = x_root_window_;
 451
 452         XSendEvent(xdisplay_,
 453                    reply_event.xclient.window,
 454                    False,
 455                    SubstructureRedirectMask | SubstructureNotifyMask,
 456                    &reply_event);
 457         XFlush(xdisplay_);
 458       }
 459       break;
 460     }
 461     case MappingNotify: {
 462       switch (xev->xmapping.request) {
 463         case MappingModifier:
 464         case MappingKeyboard:
 465           XRefreshKeyboardMapping(&xev->xmapping);
 466           break;
 467         case MappingPointer:
 468           ui::DeviceDataManagerX11::GetInstance()->UpdateButtonMap();
 469           break;
 470         default:
 471           NOTIMPLEMENTED() << " Unknown request: " << xev->xmapping.request;
 472           break;
 473       }
 474       break;
 475     }
 476   }
 477   return ui::POST_DISPATCH_STOP_PROPAGATION;
 478 }
 479
 480 ui::EventSource* WindowTreeHostX11::GetEventSource() {
 481   return this;
 482 }
 483
 484 gfx::AcceleratedWidget WindowTreeHostX11::GetAcceleratedWidget() {
 485   return xwindow_;
 486 }
 487
 488 void WindowTreeHostX11::Show() {
 489   if (!window_mapped_) {
 490     // Before we map the window, set size hints. Otherwise, some window managers
 491     // will ignore toplevel XMoveWindow commands.
 492     XSizeHints size_hints;
 493     size_hints.flags = PPosition | PWinGravity;
 494     size_hints.x = bounds_.x();
 495     size_hints.y = bounds_.y();
 496     // Set StaticGravity so that the window position is not affected by the
 497     // frame width when running with window manager.
 498     size_hints.win_gravity = StaticGravity;
 499     XSetWMNormalHints(xdisplay_, xwindow_, &size_hints);
 500
 501     XMapWindow(xdisplay_, xwindow_);
 502
 503     // We now block until our window is mapped. Some X11 APIs will crash and
 504     // burn if passed |xwindow_| before the window is mapped, and XMapWindow is
 505     // asynchronous.
 506     if (ui::X11EventSource::GetInstance())
 507       ui::X11EventSource::GetInstance()->BlockUntilWindowMapped(xwindow_);
 508     window_mapped_ = true;
 509   }
 510 }
 511
 512 void WindowTreeHostX11::Hide() {
 513   if (window_mapped_) {
 514     XWithdrawWindow(xdisplay_, xwindow_, 0);
 515     window_mapped_ = false;
 516   }
 517 }
 518
 519 gfx::Rect WindowTreeHostX11::GetBounds() const {
 520   return bounds_;
 521 }
 522
 523 void WindowTreeHostX11::SetBounds(const gfx::Rect& bounds) {
 524   // Even if the host window's size doesn't change, aura's root window
 525   // size, which is in DIP, changes when the scale changes.
 526   float current_scale = compositor()->device_scale_factor();
 527   float new_scale = gfx::Screen::GetScreenFor(window())->
 528       GetDisplayNearestWindow(window()).device_scale_factor();
 529   bool origin_changed = bounds_.origin() != bounds.origin();
 530   bool size_changed = bounds_.size() != bounds.size();
 531   XWindowChanges changes = {0};
 532   unsigned value_mask = 0;
 533
 534   if (size_changed) {
 535     changes.width = bounds.width();
 536     changes.height = bounds.height();
 537     value_mask = CWHeight | CWWidth;
 538   }
 539
 540   if (origin_changed) {
 541     changes.x = bounds.x();
 542     changes.y = bounds.y();
 543     value_mask |= CWX | CWY;
 544   }
 545   if (value_mask)
 546     XConfigureWindow(xdisplay_, xwindow_, value_mask, &changes);
 547
 548   // Assume that the resize will go through as requested, which should be the
 549   // case if we're running without a window manager.  If there's a window
 550   // manager, it can modify or ignore the request, but (per ICCCM) we'll get a
 551   // (possibly synthetic) ConfigureNotify about the actual size and correct
 552   // |bounds_| later.
 553   bounds_ = bounds;
 554   if (origin_changed)
 555     OnHostMoved(bounds.origin());
 556   if (size_changed || current_scale != new_scale) {
 557     OnHostResized(bounds.size());
 558   } else {
 559     window()->SchedulePaintInRect(window()->bounds());
 560   }
 561 }
 562
 563 gfx::Point WindowTreeHostX11::GetLocationOnNativeScreen() const {
 564   return bounds_.origin();
 565 }
 566
 567 void WindowTreeHostX11::SetCapture() {
 568   // TODO(oshima): Grab x input.
 569 }
 570
 571 void WindowTreeHostX11::ReleaseCapture() {
 572   // TODO(oshima): Release x input.
 573 }
 574
 575 void WindowTreeHostX11::PostNativeEvent(
 576     const base::NativeEvent& native_event) {
 577   DCHECK(xwindow_);
 578   DCHECK(xdisplay_);
 579   XEvent xevent = *native_event;
 580   xevent.xany.display = xdisplay_;
 581   xevent.xany.window = xwindow_;
 582
 583   switch (xevent.type) {
 584     case EnterNotify:
 585     case LeaveNotify:
 586     case MotionNotify:
 587     case KeyPress:
 588     case KeyRelease:
 589     case ButtonPress:
 590     case ButtonRelease: {
 591       // The fields used below are in the same place for all of events
 592       // above. Using xmotion from XEvent's unions to avoid repeating
 593       // the code.
 594       xevent.xmotion.root = x_root_window_;
 595       xevent.xmotion.time = CurrentTime;
 596
 597       gfx::Point point(xevent.xmotion.x, xevent.xmotion.y);
 598       ConvertPointToNativeScreen(&point);
 599       xevent.xmotion.x_root = point.x();
 600       xevent.xmotion.y_root = point.y();
 601     }
 602     default:
 603       break;
 604   }
 605   XSendEvent(xdisplay_, xwindow_, False, 0, &xevent);
 606   XFlush(xdisplay_);
 607 }
 608
 609 void WindowTreeHostX11::SetCursorNative(gfx::NativeCursor cursor) {
 610   if (cursor == current_cursor_)
 611     return;
 612   current_cursor_ = cursor;
 613   SetCursorInternal(cursor);
 614 }
 615
 616 void WindowTreeHostX11::MoveCursorToNative(const gfx::Point& location) {
 617   XWarpPointer(xdisplay_, None, x_root_window_, 0, 0, 0, 0,
 618                bounds_.x() + location.x(),
 619                bounds_.y() + location.y());
 620 }
 621
 622 void WindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
 623 }
 624
 625 ui::EventProcessor* WindowTreeHostX11::GetEventProcessor() {
 626   return dispatcher();
 627 }
 628
 629 void WindowTreeHostX11::DispatchXI2Event(const base::NativeEvent& event) {
 630   ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
 631   XEvent* xev = event;
 632   XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data);
 633   if (!factory->ShouldProcessXI2Event(xev))
 634     return;
 635
 636   TRACE_EVENT1("input", "WindowTreeHostX11::DispatchXI2Event",
 637                "event_latency_us",
 638                (ui::EventTimeForNow() - ui::EventTimeFromNative(event)).
 639                  InMicroseconds());
 640
 641   int num_coalesced = 0;
 642   XEvent last_event;
 643   if (xev->xgeneric.evtype == XI_Motion) {
 644     // If this is a motion event, we want to coalesce all pending motion
 645     // events that are at the top of the queue. Note, we don't coalesce
 646     // touch update events here.
 647     num_coalesced = ui::CoalescePendingMotionEvents(xev, &last_event);
 648     if (num_coalesced > 0)
 649       xev = &last_event;
 650   }
 651   ui::EventType type = ui::EventTypeFromNative(xev);
 652
 653   switch (type) {
 654     case ui::ET_TOUCH_MOVED:
 655     case ui::ET_TOUCH_PRESSED:
 656     case ui::ET_TOUCH_CANCELLED:
 657     case ui::ET_TOUCH_RELEASED: {
 658       ui::TouchEvent touchev(xev);
 659       if (ui::DeviceDataManagerX11::GetInstance()->TouchEventNeedsCalibrate(
 660               xiev->deviceid)) {
 661         touch_calibrate_->Calibrate(&touchev, bounds_);
 662       }
 663       TranslateAndDispatchLocatedEvent(&touchev);
 664       break;
 665     }
 666     case ui::ET_MOUSE_MOVED:
 667     case ui::ET_MOUSE_DRAGGED:
 668     case ui::ET_MOUSE_PRESSED:
 669     case ui::ET_MOUSE_RELEASED:
 670     case ui::ET_MOUSE_ENTERED:
 671     case ui::ET_MOUSE_EXITED: {
 672       ui::MouseEvent mouseev(xev);
 673       TranslateAndDispatchLocatedEvent(&mouseev);
 674       break;
 675     }
 676     case ui::ET_MOUSEWHEEL: {
 677       ui::MouseWheelEvent mouseev(xev);
 678       TranslateAndDispatchLocatedEvent(&mouseev);
 679       break;
 680     }
 681     case ui::ET_SCROLL_FLING_START:
 682     case ui::ET_SCROLL_FLING_CANCEL:
 683     case ui::ET_SCROLL: {
 684       ui::ScrollEvent scrollev(xev);
 685       SendEventToProcessor(&scrollev);
 686       break;
 687     }
 688     case ui::ET_KEY_PRESSED:
 689     case ui::ET_KEY_RELEASED: {
 690       ui::KeyEvent key_event(xev);
 691       SendEventToProcessor(&key_event);
 692       break;
 693     }
 694     case ui::ET_UMA_DATA:
 695       break;
 696     case ui::ET_UNKNOWN:
 697       break;
 698     default:
 699       NOTREACHED();
 700   }
 701
 702   // If we coalesced an event we need to free its cookie.
 703   if (num_coalesced > 0)
 704     XFreeEventData(xev->xgeneric.display, &last_event.xcookie);
 705 }
 706
 707 void WindowTreeHostX11::SetCursorInternal(gfx::NativeCursor cursor) {
 708   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 709 }
 710
 711 void WindowTreeHostX11::OnConfigureNotify() {}
 712
 713 void WindowTreeHostX11::TranslateAndDispatchLocatedEvent(
 714     ui::LocatedEvent* event) {
 715   SendEventToProcessor(event);
 716 }
 717
 718 // static
 719 WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) {
 720   return new WindowTreeHostX11(bounds);
 721 }
 722
 723 // static
 724 gfx::Size WindowTreeHost::GetNativeScreenSize() {
 725   ::XDisplay* xdisplay = gfx::GetXDisplay();
 726   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 727 }
 728
 729 namespace test {
 730
 731 void SetUseOverrideRedirectWindowByDefault(bool override_redirect) {
 732   default_override_redirect = override_redirect;
 733 }
 734
 735 }  // namespace test
 736 }  // namespace aura