Introdcue AshWindowTreeHost and move ash/chrome specific code in WTH to ash.

ui/aura/window_tree_host_x11.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/aura/window_tree_host_x11.h"
 
 #include <strings.h>
 #include <X11/cursorfont.h>
-#include <X11/extensions/Xfixes.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
 #include <X11/Xatom.h>
 #include <X11/Xcursor/Xcursor.h>
 #include <X11/Xlib.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "ui/aura/client/cursor_client.h"
-#include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
+#include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/event.h"
 #include "ui/events/event_switches.h"
@@ skipping 59 matching lines @@
     XISetMask(mask, XI_TouchEnd);
     XISelectEvents(display, root_window, &evmask, 1);
   }
 #endif
 }
 
 bool default_override_redirect = false;
 
 }  // namespace
 
-namespace internal {
-
-// Accomplishes 2 tasks concerning touch event calibration:
-// 1. Being a message-pump observer,
-//    routes all the touch events to the X root window,
-//    where they can be calibrated later.
-// 2. Has the Calibrate method that does the actual bezel calibration,
-//    when invoked from X root window's event dispatcher.
-class TouchEventCalibrate : public base::MessagePumpObserver {
- public:
-  TouchEventCalibrate()
-    : left_(0),
-      right_(0),
-      top_(0),
-      bottom_(0) {
-    base::MessageLoopForUI::current()->AddObserver(this);
-#if defined(USE_XI2_MT)
-    std::vector<std::string> parts;
-    if (Tokenize(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-        switches::kTouchCalibration), ",", &parts) >= 4) {
-      if (!base::StringToInt(parts[0], &left_))
-        DLOG(ERROR) << "Incorrect left border calibration value passed.";
-      if (!base::StringToInt(parts[1], &right_))
-        DLOG(ERROR) << "Incorrect right border calibration value passed.";
-      if (!base::StringToInt(parts[2], &top_))
-        DLOG(ERROR) << "Incorrect top border calibration value passed.";
-      if (!base::StringToInt(parts[3], &bottom_))
-        DLOG(ERROR) << "Incorrect bottom border calibration value passed.";
-    }
-#endif  // defined(USE_XI2_MT)
-  }
-
-  virtual ~TouchEventCalibrate() {
-    base::MessageLoopForUI::current()->RemoveObserver(this);
-  }
-
-  // Modify the location of the |event|,
-  // expanding it from |bounds| to (|bounds| + bezels).
-  // Required when touchscreen is bigger than screen (i.e. has bezels),
-  // because we receive events in touchscreen coordinates,
-  // which need to be expanded when converting to screen coordinates,
-  // so that location on bezels will be outside of screen area.
-  void Calibrate(ui::TouchEvent* event, const gfx::Rect& bounds) {
-#if defined(USE_XI2_MT)
-    int x = event->x();
-    int y = event->y();
-
-    if (!left_ && !right_ && !top_ && !bottom_)
-      return;
-
-    const int resolution_x = bounds.width();
-    const int resolution_y = bounds.height();
-    // The "grace area" (10% in this case) is to make it easier for the user to
-    // navigate to the corner.
-    const double kGraceAreaFraction = 0.1;
-    if (left_ || right_) {
-      // Offset the x position to the real
-      x -= left_;
-      // Check if we are in the grace area of the left side.
-      // Note: We might not want to do this when the gesture is locked?
-      if (x < 0 && x > -left_ * kGraceAreaFraction)
-        x = 0;
-      // Check if we are in the grace area of the right side.
-      // Note: We might not want to do this when the gesture is locked?
-      if (x > resolution_x - left_ &&
-          x < resolution_x - left_ + right_ * kGraceAreaFraction)
-        x = resolution_x - left_;
-      // Scale the screen area back to the full resolution of the screen.
-      x = (x * resolution_x) / (resolution_x - (right_ + left_));
-    }
-    if (top_ || bottom_) {
-      // When there is a top bezel we add our border,
-      y -= top_;
-
-      // Check if we are in the grace area of the top side.
-      // Note: We might not want to do this when the gesture is locked?
-      if (y < 0 && y > -top_ * kGraceAreaFraction)
-        y = 0;
-
-      // Check if we are in the grace area of the bottom side.
-      // Note: We might not want to do this when the gesture is locked?
-      if (y > resolution_y - top_ &&
-          y < resolution_y - top_ + bottom_ * kGraceAreaFraction)
-        y = resolution_y - top_;
-      // Scale the screen area back to the full resolution of the screen.
-      y = (y * resolution_y) / (resolution_y - (bottom_ + top_));
-    }
-
-    // Set the modified coordinate back to the event.
-    if (event->root_location() == event->location()) {
-      // Usually those will be equal,
-      // if not, I am not sure what the correct value should be.
-      event->set_root_location(gfx::Point(x, y));
-    }
-    event->set_location(gfx::Point(x, y));
-#endif  // defined(USE_XI2_MT)
-  }
-
- private:
-  // Overridden from base::MessagePumpObserver:
-  virtual void WillProcessEvent(const base::NativeEvent& event) OVERRIDE {
-#if defined(USE_XI2_MT)
-    if (event->type == GenericEvent &&
-        (event->xgeneric.evtype == XI_TouchBegin ||
-         event->xgeneric.evtype == XI_TouchUpdate ||
-         event->xgeneric.evtype == XI_TouchEnd)) {
-      XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(event->xcookie.data);
-      xievent->event = xievent->root;
-      xievent->event_x = xievent->root_x;
-      xievent->event_y = xievent->root_y;
-    }
-#endif  // defined(USE_XI2_MT)
-  }
-
-  virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE {
-  }
-
-  // The difference in screen's native resolution pixels between
-  // the border of the touchscreen and the border of the screen,
-  // aka bezel sizes.
-  int left_;
-  int right_;
-  int top_;
-  int bottom_;
-
-  DISALLOW_COPY_AND_ASSIGN(TouchEventCalibrate);
-};
-
-}  // namespace internal
-
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHostX11
 
 WindowTreeHostX11::WindowTreeHostX11(const gfx::Rect& bounds)
     : xdisplay_(gfx::GetXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(ui::kCursorNull),
       window_mapped_(false),
       bounds_(bounds),
-      is_internal_display_(false),
-      touch_calibrate_(new internal::TouchEventCalibrate),
       atom_cache_(xdisplay_, kAtomsToCache) {
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
   swa.override_redirect = default_override_redirect;
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
       bounds.x(), bounds.y(), bounds.width(), bounds.height(),
       0,               // border width
       CopyFromParent,  // depth
@@ skipping 38 matching lines @@
   XChangeProperty(xdisplay_,
                   xwindow_,
                   atom_cache_.GetAtom("_NET_WM_PID"),
                   XA_CARDINAL,
                   32,
                   PropModeReplace,
                   reinterpret_cast<unsigned char*>(&pid), 1);
 
   XRRSelectInput(xdisplay_, x_root_window_,
                  RRScreenChangeNotifyMask | RROutputChangeNotifyMask);
-  Env::GetInstance()->AddObserver(this);
   CreateCompositor(GetAcceleratedWidget());
 }
 
 WindowTreeHostX11::~WindowTreeHostX11() {
-  Env::GetInstance()->RemoveObserver(this);
   if (ui::PlatformEventSource::GetInstance())
     ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
 
-  UnConfineCursor();
-
   DestroyCompositor();
   DestroyDispatcher();
   XDestroyWindow(xdisplay_, xwindow_);
 }
 
 bool WindowTreeHostX11::CanDispatchEvent(const ui::PlatformEvent& event) {
   ::Window target = FindEventTarget(event);
   return target == xwindow_ || target == x_root_window_;
 }
 
@@ skipping 12 matching lines @@
           client::GetCursorClient(root_window);
       if (cursor_client) {
         const gfx::Display display = gfx::Screen::GetScreenFor(root_window)->
             GetDisplayNearestWindow(root_window);
         cursor_client->SetDisplay(display);
       }
       ui::MouseEvent mouse_event(xev);
       // EnterNotify creates ET_MOUSE_MOVE. Mark as synthesized as this is not
       // real mouse move event.
       mouse_event.set_flags(mouse_event.flags() | ui::EF_IS_SYNTHESIZED);
-      TranslateAndDispatchMouseEvent(&mouse_event);
+      TranslateAndDispatchLocatedEvent(&mouse_event);
       break;
     }
     case LeaveNotify: {
       ui::MouseEvent mouse_event(xev);
-      TranslateAndDispatchMouseEvent(&mouse_event);
+      TranslateAndDispatchLocatedEvent(&mouse_event);
       break;
     }
     case Expose: {
       gfx::Rect damage_rect(xev->xexpose.x, xev->xexpose.y,
                             xev->xexpose.width, xev->xexpose.height);
       compositor()->ScheduleRedrawRect(damage_rect);
       break;
     }
     case KeyPress: {
       ui::KeyEvent keydown_event(xev, false);
       SendEventToProcessor(&keydown_event);
       break;
     }
     case KeyRelease: {
       ui::KeyEvent keyup_event(xev, false);
       SendEventToProcessor(&keyup_event);
       break;
     }
     case ButtonPress:
     case ButtonRelease: {
       switch (ui::EventTypeFromNative(xev)) {
         case ui::ET_MOUSEWHEEL: {
           ui::MouseWheelEvent mouseev(xev);
-          TranslateAndDispatchMouseEvent(&mouseev);
+          TranslateAndDispatchLocatedEvent(&mouseev);
           break;
         }
         case ui::ET_MOUSE_PRESSED:
         case ui::ET_MOUSE_RELEASED: {
           ui::MouseEvent mouseev(xev);
-          TranslateAndDispatchMouseEvent(&mouseev);
+          TranslateAndDispatchLocatedEvent(&mouseev);
           break;
         }
         case ui::ET_UNKNOWN:
           // No event is created for X11-release events for mouse-wheel buttons.
           break;
         default:
           NOTREACHED();
       }
       break;
     }
     case FocusOut:
       if (xev->xfocus.mode != NotifyGrab)
         OnHostLostWindowCapture();
       break;
     case ConfigureNotify: {
       DCHECK_EQ(xwindow_, xev->xconfigure.event);
       DCHECK_EQ(xwindow_, xev->xconfigure.window);
       // It's possible that the X window may be resized by some other means
       // than from within aura (e.g. the X window manager can change the
       // size). Make sure the root window size is maintained properly.
       gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
           xev->xconfigure.width, xev->xconfigure.height);
       bool size_changed = bounds_.size() != bounds.size();
       bool origin_changed = bounds_.origin() != bounds.origin();
       bounds_ = bounds;
-      UpdateIsInternalDisplay();
-      // Always update barrier and mouse location because |bounds_| might
-      // have already been updated in |SetBounds|.
-      if (pointer_barriers_) {
-        UnConfineCursor();
-        ConfineCursorToRootWindow();
-      }
+      OnConfigureNotify();
       if (size_changed)
         OnHostResized(bounds.size());
       if (origin_changed)
         OnHostMoved(bounds_.origin());
       break;
     }
     case GenericEvent:
       DispatchXI2Event(xev);
       break;
     case ClientMessage: {
@@ skipping 40 matching lines @@
             next_event.xmotion.subwindow == xev->xmotion.subwindow &&
             next_event.xmotion.state == xev->xmotion.state) {
           XNextEvent(xev->xany.display, &last_event);
           xev = &last_event;
         } else {
           break;
         }
       }
 
       ui::MouseEvent mouseev(xev);
-      TranslateAndDispatchMouseEvent(&mouseev);
+      TranslateAndDispatchLocatedEvent(&mouseev);
       break;
     }
   }
   return ui::POST_DISPATCH_STOP_PROPAGATION;
 }
 
 gfx::AcceleratedWidget WindowTreeHostX11::GetAcceleratedWidget() {
   return xwindow_;
 }
 
@@ skipping 21 matching lines @@
   }
 }
 
 void WindowTreeHostX11::Hide() {
   if (window_mapped_) {
     XWithdrawWindow(xdisplay_, xwindow_, 0);
     window_mapped_ = false;
   }
 }
 
-void WindowTreeHostX11::ToggleFullScreen() {
-  NOTIMPLEMENTED();
-}
-
 gfx::Rect WindowTreeHostX11::GetBounds() const {
   return bounds_;
 }
 
 void WindowTreeHostX11::SetBounds(const gfx::Rect& bounds) {
   // Even if the host window's size doesn't change, aura's root window
   // size, which is in DIP, changes when the scale changes.
   float current_scale = compositor()->device_scale_factor();
   float new_scale = gfx::Screen::GetScreenFor(window())->
       GetDisplayNearestWindow(window()).device_scale_factor();
@@ skipping 15 matching lines @@
   }
   if (value_mask)
     XConfigureWindow(xdisplay_, xwindow_, value_mask, &changes);
 
   // Assume that the resize will go through as requested, which should be the
   // case if we're running without a window manager.  If there's a window
   // manager, it can modify or ignore the request, but (per ICCCM) we'll get a
   // (possibly synthetic) ConfigureNotify about the actual size and correct
   // |bounds_| later.
   bounds_ = bounds;
-  UpdateIsInternalDisplay();
   if (origin_changed)
     OnHostMoved(bounds.origin());
   if (size_changed || current_scale != new_scale) {
     OnHostResized(bounds.size());
   } else {
     window()->SchedulePaintInRect(window()->bounds());
   }
 }
 
-gfx::Insets WindowTreeHostX11::GetInsets() const {
-  return insets_;
-}
-
-void WindowTreeHostX11::SetInsets(const gfx::Insets& insets) {
-  insets_ = insets;
-  if (pointer_barriers_) {
-    UnConfineCursor();
-    ConfineCursorToRootWindow();
-  }
-}
-
 gfx::Point WindowTreeHostX11::GetLocationOnNativeScreen() const {
   return bounds_.origin();
 }
 
 void WindowTreeHostX11::SetCapture() {
   // TODO(oshima): Grab x input.
 }
 
 void WindowTreeHostX11::ReleaseCapture() {
   // TODO(oshima): Release x input.
@@ skipping 16 matching lines @@
                 &child_return,
                 &root_x_return, &root_y_return,
                 &win_x_return, &win_y_return,
                 &mask_return);
   *location_return = gfx::Point(max(0, min(bounds_.width(), win_x_return)),
                                 max(0, min(bounds_.height(), win_y_return)));
   return (win_x_return >= 0 && win_x_return < bounds_.width() &&
           win_y_return >= 0 && win_y_return < bounds_.height());
 }
 
-bool WindowTreeHostX11::ConfineCursorToRootWindow() {
-#if XFIXES_MAJOR >= 5
-  DCHECK(!pointer_barriers_.get());
-  if (pointer_barriers_)
-    return false;
-  pointer_barriers_.reset(new XID[4]);
-  gfx::Rect bounds(bounds_);
-  bounds.Inset(insets_);
-  // Horizontal, top barriers.
-  pointer_barriers_[0] = XFixesCreatePointerBarrier(
-      xdisplay_, x_root_window_,
-      bounds.x(), bounds.y(), bounds.right(), bounds.y(),
-      BarrierPositiveY,
-      0, XIAllDevices);
-  // Horizontal, bottom barriers.
-  pointer_barriers_[1] = XFixesCreatePointerBarrier(
-      xdisplay_, x_root_window_,
-      bounds.x(), bounds.bottom(), bounds.right(),  bounds.bottom(),
-      BarrierNegativeY,
-      0, XIAllDevices);
-  // Vertical, left  barriers.
-  pointer_barriers_[2] = XFixesCreatePointerBarrier(
-      xdisplay_, x_root_window_,
-      bounds.x(), bounds.y(), bounds.x(), bounds.bottom(),
-      BarrierPositiveX,
-      0, XIAllDevices);
-  // Vertical, right barriers.
-  pointer_barriers_[3] = XFixesCreatePointerBarrier(
-      xdisplay_, x_root_window_,
-      bounds.right(), bounds.y(), bounds.right(), bounds.bottom(),
-      BarrierNegativeX,
-      0, XIAllDevices);
-#endif
-  return true;
-}
-
-void WindowTreeHostX11::UnConfineCursor() {
-#if XFIXES_MAJOR >= 5
-  if (pointer_barriers_) {
-    XFixesDestroyPointerBarrier(xdisplay_, pointer_barriers_[0]);
-    XFixesDestroyPointerBarrier(xdisplay_, pointer_barriers_[1]);
-    XFixesDestroyPointerBarrier(xdisplay_, pointer_barriers_[2]);
-    XFixesDestroyPointerBarrier(xdisplay_, pointer_barriers_[3]);
-    pointer_barriers_.reset();
-  }
-#endif
-}
-
 void WindowTreeHostX11::PostNativeEvent(
     const base::NativeEvent& native_event) {
   DCHECK(xwindow_);
   DCHECK(xdisplay_);
   XEvent xevent = *native_event;
   xevent.xany.display = xdisplay_;
   xevent.xany.window = xwindow_;
 
   switch (xevent.type) {
     case EnterNotify:
@@ skipping 31 matching lines @@
   SetCursorInternal(cursor);
 }
 
 void WindowTreeHostX11::MoveCursorToNative(const gfx::Point& location) {
   XWarpPointer(xdisplay_, None, x_root_window_, 0, 0, 0, 0,
                bounds_.x() + location.x(),
                bounds_.y() + location.y());
 }
 
 void WindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
-  SetCrOSTapPaused(!show);
-}
-
-void WindowTreeHostX11::OnWindowInitialized(Window* window) {
-}
-
-void WindowTreeHostX11::OnHostInitialized(WindowTreeHost* host) {
-  // TODO(beng): I'm not sure that this comment makes much sense anymore??
-  // UpdateIsInternalDisplay relies on WED's kDisplayIdKey property being set
-  // available by the time WED::Init is called. (set in
-  // DisplayManager::CreateRootWindowForDisplay)
-  // Ready when NotifyHostInitialized is called from WED::Init.
-  if (host != this)
-    return;
-  UpdateIsInternalDisplay();
-
-  // We have to enable Tap-to-click by default because the cursor is set to
-  // visible in Shell::InitRootWindowController.
-  SetCrOSTapPaused(false);
 }
 
 ui::EventProcessor* WindowTreeHostX11::GetEventProcessor() {
   return dispatcher();
 }
 
 void WindowTreeHostX11::DispatchXI2Event(const base::NativeEvent& event) {
   ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
   XEvent* xev = event;
   if (!factory->ShouldProcessXI2Event(xev))
@@ skipping 15 matching lines @@
     case ui::ET_TOUCH_RELEASED: {
 #if defined(OS_CHROMEOS)
       // Bail out early before generating a ui::TouchEvent if this event
       // is not within the range of this RootWindow. Converting an xevent
       // to ui::TouchEvent might change the state of the global touch tracking
       // state, e.g. touch release event can remove the touch id from the
       // record, and doing this multiple time when there are multiple
       // RootWindow will cause problem. So only generate the ui::TouchEvent
       // when we are sure it belongs to this RootWindow.
       if (base::SysInfo::IsRunningOnChromeOS() &&
-          !bounds_.Contains(ui::EventLocationFromNative(xev)))
-        break;
-#endif  // defined(OS_CHROMEOS)
+          !bounds().Contains(ui::EventLocationFromNative(xev)))
+        return;

[Yufeng Shen (Slow to review), 2014/04/09 21:35:51]

Can we have a
virtual bool WindowTreeHostX11::IsTouchEventTargetingThisRootWindow() {
   return true;
}

which gets called here
 
and have
bool AshWindowTreeHostX11::IsTouchEventTargetingThisRootWindow() {
#if defined(OS_CHROMEOS)
if (base::SysInfo::IsRunningOnChromeOS() &&
!bounds().Contains(ui::EventLocationFromNative(xev)))
return false;
}
#endif
return true;
}

This way we move all the chromeos specific code into AshWTHX11. Does this make
sense ?

[oshima, 2014/04/09 23:52:15]

I was actually wondering why this needs to be cros specific, and if we can
simply remove ifdef and IsRunningOnChromeOS. Do you know why?

In any case, let me land this change first (becuase CL is big) and
address this in separate CL if necessary.

+#endif
       ui::TouchEvent touchev(xev);
-#if defined(OS_CHROMEOS)
-      if (base::SysInfo::IsRunningOnChromeOS()) {
-        // X maps the touch-surface to the size of the X root-window.
-        // In multi-monitor setup, Coordinate Transformation Matrix
-        // repositions the touch-surface onto part of X root-window
-        // containing aura root-window corresponding to the touchscreen.
-        // However, if aura root-window has non-zero origin,
-        // we need to relocate the event into aura root-window coordinates.
-        touchev.Relocate(bounds_.origin());
-#if defined(USE_XI2_MT)
-        if (is_internal_display_)
-          touch_calibrate_->Calibrate(&touchev, bounds_);
-#endif  // defined(USE_XI2_MT)
-      }
-#endif  // defined(OS_CHROMEOS)
-      SendEventToProcessor(&touchev);
+      TranslateAndDispatchLocatedEvent(&touchev);
       break;
     }
     case ui::ET_MOUSE_MOVED:
     case ui::ET_MOUSE_DRAGGED:
     case ui::ET_MOUSE_PRESSED:
     case ui::ET_MOUSE_RELEASED:
     case ui::ET_MOUSE_ENTERED:
     case ui::ET_MOUSE_EXITED: {
       if (type == ui::ET_MOUSE_MOVED || type == ui::ET_MOUSE_DRAGGED) {
         // If this is a motion event, we want to coalesce all pending motion
         // events that are at the top of the queue.
         num_coalesced = ui::CoalescePendingMotionEvents(xev, &last_event);
         if (num_coalesced > 0)
           xev = &last_event;
       }
       ui::MouseEvent mouseev(xev);
-      TranslateAndDispatchMouseEvent(&mouseev);
+      TranslateAndDispatchLocatedEvent(&mouseev);
       break;
     }
     case ui::ET_MOUSEWHEEL: {
       ui::MouseWheelEvent mouseev(xev);
-      TranslateAndDispatchMouseEvent(&mouseev);
+      TranslateAndDispatchLocatedEvent(&mouseev);
       break;
     }
     case ui::ET_SCROLL_FLING_START:
     case ui::ET_SCROLL_FLING_CANCEL:
     case ui::ET_SCROLL: {
       ui::ScrollEvent scrollev(xev);
       SendEventToProcessor(&scrollev);
       break;
     }
     case ui::ET_UMA_DATA:
@@ skipping 13 matching lines @@
   // Per ICCCM 2.8, "Manager Selections", window managers should take ownership
   // of WM_Sn selections (where n is a screen number).
   return XGetSelectionOwner(
       xdisplay_, atom_cache_.GetAtom("WM_S0")) != None;
 }
 
 void WindowTreeHostX11::SetCursorInternal(gfx::NativeCursor cursor) {
   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 }
 
-void WindowTreeHostX11::TranslateAndDispatchMouseEvent(
-    ui::MouseEvent* event) {
-  Window* root_window = window();
-  client::ScreenPositionClient* screen_position_client =
-      client::GetScreenPositionClient(root_window);
-  gfx::Rect local(bounds_.size());
+void WindowTreeHostX11::OnConfigureNotify() {}
 
-  if (screen_position_client && !local.Contains(event->location())) {
-    gfx::Point location(event->location());
-    // In order to get the correct point in screen coordinates
-    // during passive grab, we first need to find on which host window
-    // the mouse is on, and find out the screen coordinates on that
-    // host window, then convert it back to this host window's coordinate.
-    screen_position_client->ConvertHostPointToScreen(root_window, &location);
-    screen_position_client->ConvertPointFromScreen(root_window, &location);
-    ConvertPointToHost(&location);
-    event->set_location(location);
-    event->set_root_location(location);
-  }
+void WindowTreeHostX11::TranslateAndDispatchLocatedEvent(
+    ui::LocatedEvent* event) {
   SendEventToProcessor(event);
 }
 
-void WindowTreeHostX11::UpdateIsInternalDisplay() {
-  Window* root_window = window();
-  gfx::Screen* screen = gfx::Screen::GetScreenFor(root_window);
-  gfx::Display display = screen->GetDisplayNearestWindow(root_window);
-  is_internal_display_ = display.IsInternal();
-}
-
-void WindowTreeHostX11::SetCrOSTapPaused(bool state) {
-#if defined(OS_CHROMEOS)
-  if (!ui::IsXInput2Available())
-    return;
-  // Temporarily pause tap-to-click when the cursor is hidden.
-  Atom prop = atom_cache_.GetAtom("Tap Paused");
-  unsigned char value = state;
-  XIDeviceList dev_list =
-      ui::DeviceListCacheX::GetInstance()->GetXI2DeviceList(xdisplay_);
-
-  // Only slave pointer devices could possibly have tap-paused property.
-  for (int i = 0; i < dev_list.count; i++) {
-    if (dev_list[i].use == XISlavePointer) {
-      Atom old_type;
-      int old_format;
-      unsigned long old_nvalues, bytes;
-      unsigned char* data;
-      int result = XIGetProperty(xdisplay_, dev_list[i].deviceid, prop, 0, 0,
-                                 False, AnyPropertyType, &old_type, &old_format,
-                                 &old_nvalues, &bytes, &data);
-      if (result != Success)
-        continue;
-      XFree(data);
-      XIChangeProperty(xdisplay_, dev_list[i].deviceid, prop, XA_INTEGER, 8,
-                       PropModeReplace, &value, 1);
-    }
-  }
-#endif
-}
-
 // static
 WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) {
   return new WindowTreeHostX11(bounds);
 }
 
 // static
 gfx::Size WindowTreeHost::GetNativeScreenSize() {
   ::XDisplay* xdisplay = gfx::GetXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 namespace test {
 
 void SetUseOverrideRedirectWindowByDefault(bool override_redirect) {
   default_override_redirect = override_redirect;
 }
 
 }  // namespace test
 }  // namespace aura