Rename RootWindowHost to WindowTreeHost

ui/aura/root_window_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/root_window_host_x11.h"
 
 #include <strings.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/XInput2.h>
@@ skipping 248 matching lines @@
   int right_;
   int top_;
   int bottom_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchEventCalibrate);
 };
 
 }  // namespace internal
 
 ////////////////////////////////////////////////////////////////////////////////
-// RootWindowHostX11::MouseMoveFilter filters out the move events that
+// WindowTreeHostX11::MouseMoveFilter filters out the move events that
 // jump back and forth between two points. This happens when sub pixel mouse
 // move is enabled and mouse move events could be jumping between two neighbor
 // pixels, e.g. move(0,0), move(1,0), move(0,0), move(1,0) and on and on.
 // The filtering is done by keeping track of the last two event locations and
 // provides a Filter method to find out whether a mouse event is in a different
 // location and should be processed.
 
-class RootWindowHostX11::MouseMoveFilter {
+class WindowTreeHostX11::MouseMoveFilter {
  public:
   MouseMoveFilter() : insert_index_(0) {
     for (size_t i = 0; i < kMaxEvents; ++i) {
       const int int_max = std::numeric_limits<int>::max();
       recent_locations_[i] = gfx::Point(int_max, int_max);
     }
   }
   ~MouseMoveFilter() {}
 
   // Returns true if |event| is known and should be ignored.
@@ skipping 12 matching lines @@
  private:
   static const size_t kMaxEvents = 2;
 
   gfx::Point recent_locations_[kMaxEvents];
   size_t insert_index_;
 
   DISALLOW_COPY_AND_ASSIGN(MouseMoveFilter);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// RootWindowHostX11
+// WindowTreeHostX11
 
-RootWindowHostX11::RootWindowHostX11(const gfx::Rect& bounds)
+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),
       mouse_move_filter_(new MouseMoveFilter),
       atom_cache_(xdisplay_, kAtomsToCache),
@@ skipping 52 matching lines @@
                   32,
                   PropModeReplace,
                   reinterpret_cast<unsigned char*>(&pid), 1);
 
   XRRSelectInput(xdisplay_, x_root_window_,
                  RRScreenChangeNotifyMask | RROutputChangeNotifyMask);
   Env::GetInstance()->AddObserver(this);
   CreateCompositor(GetAcceleratedWidget());
 }
 
-RootWindowHostX11::~RootWindowHostX11() {
+WindowTreeHostX11::~WindowTreeHostX11() {
   Env::GetInstance()->RemoveObserver(this);
   base::MessagePumpX11::Current()->RemoveDispatcherForRootWindow(this);
   base::MessagePumpX11::Current()->RemoveDispatcherForWindow(xwindow_);
 
   UnConfineCursor();
 
   XDestroyWindow(xdisplay_, xwindow_);
 }
 
-bool RootWindowHostX11::Dispatch(const base::NativeEvent& event) {
+bool WindowTreeHostX11::Dispatch(const base::NativeEvent& event) {
   XEvent* xev = event;
 
   if (FindEventTarget(event) == x_root_window_)
     return DispatchEventForRootWindow(event);
 
   switch (xev->type) {
     case EnterNotify: {
       aura::Window* root_window = GetRootWindow()->window();
       client::CursorClient* cursor_client =
           client::GetCursorClient(root_window);
@@ skipping 93 matching lines @@
         delegate_->OnHostMoved(bounds_.origin());
       break;
     }
     case GenericEvent:
       DispatchXI2Event(event);
       break;
     case ClientMessage: {
       Atom message_type = static_cast<Atom>(xev->xclient.data.l[0]);
       if (message_type == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
         // We have received a close message from the window manager.
-        delegate_->AsRootWindow()->OnRootWindowHostCloseRequested();
+        delegate_->AsRootWindow()->OnWindowTreeHostCloseRequested();
       } else if (message_type == atom_cache_.GetAtom("_NET_WM_PING")) {
         XEvent reply_event = *xev;
         reply_event.xclient.window = x_root_window_;
 
         XSendEvent(xdisplay_,
                    reply_event.xclient.window,
                    False,
                    SubstructureRedirectMask | SubstructureNotifyMask,
                    &reply_event);
       }
@@ skipping 34 matching lines @@
       }
 
       ui::MouseEvent mouseev(xev);
       TranslateAndDispatchMouseEvent(&mouseev);
       break;
     }
   }
   return true;
 }
 
-RootWindow* RootWindowHostX11::GetRootWindow() {
+RootWindow* WindowTreeHostX11::GetRootWindow() {
   return delegate_->AsRootWindow();
 }
 
-gfx::AcceleratedWidget RootWindowHostX11::GetAcceleratedWidget() {
+gfx::AcceleratedWidget WindowTreeHostX11::GetAcceleratedWidget() {
   return xwindow_;
 }
 
-void RootWindowHostX11::Show() {
+void WindowTreeHostX11::Show() {
   if (!window_mapped_) {
     // Before we map the window, set size hints. Otherwise, some window managers
     // will ignore toplevel XMoveWindow commands.
     XSizeHints size_hints;
     size_hints.flags = PPosition | PWinGravity;
     size_hints.x = bounds_.x();
     size_hints.y = bounds_.y();
     // Set StaticGravity so that the window position is not affected by the
     // frame width when running with window manager.
     size_hints.win_gravity = StaticGravity;
     XSetWMNormalHints(xdisplay_, xwindow_, &size_hints);
 
     XMapWindow(xdisplay_, xwindow_);
 
     // We now block until our window is mapped. Some X11 APIs will crash and
     // burn if passed |xwindow_| before the window is mapped, and XMapWindow is
     // asynchronous.
     base::MessagePumpX11::Current()->BlockUntilWindowMapped(xwindow_);
     window_mapped_ = true;
   }
 }
 
-void RootWindowHostX11::Hide() {
+void WindowTreeHostX11::Hide() {
   if (window_mapped_) {
     XWithdrawWindow(xdisplay_, xwindow_, 0);
     window_mapped_ = false;
   }
 }
 
-void RootWindowHostX11::ToggleFullScreen() {
+void WindowTreeHostX11::ToggleFullScreen() {
   NOTIMPLEMENTED();
 }
 
-gfx::Rect RootWindowHostX11::GetBounds() const {
+gfx::Rect WindowTreeHostX11::GetBounds() const {
   return bounds_;
 }
 
-void RootWindowHostX11::SetBounds(const gfx::Rect& 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(
       delegate_->AsRootWindow()->window())->GetDisplayNearestWindow(
           delegate_->AsRootWindow()->window()).device_scale_factor();
   bool origin_changed = bounds_.origin() != bounds.origin();
   bool size_changed = bounds_.size() != bounds.size();
   XWindowChanges changes = {0};
   unsigned value_mask = 0;
@@ skipping 22 matching lines @@
   if (origin_changed)
     delegate_->OnHostMoved(bounds.origin());
   if (size_changed || current_scale != new_scale) {
     NotifyHostResized(bounds.size());
   } else {
     delegate_->AsRootWindow()->window()->SchedulePaintInRect(
         delegate_->AsRootWindow()->window()->bounds());
   }
 }
 
-gfx::Insets RootWindowHostX11::GetInsets() const {
+gfx::Insets WindowTreeHostX11::GetInsets() const {
   return insets_;
 }
 
-void RootWindowHostX11::SetInsets(const gfx::Insets& insets) {
+void WindowTreeHostX11::SetInsets(const gfx::Insets& insets) {
   insets_ = insets;
   if (pointer_barriers_) {
     UnConfineCursor();
     ConfineCursorToRootWindow();
   }
 }
 
-gfx::Point RootWindowHostX11::GetLocationOnNativeScreen() const {
+gfx::Point WindowTreeHostX11::GetLocationOnNativeScreen() const {
   return bounds_.origin();
 }
 
-void RootWindowHostX11::SetCapture() {
+void WindowTreeHostX11::SetCapture() {
   // TODO(oshima): Grab x input.
 }
 
-void RootWindowHostX11::ReleaseCapture() {
+void WindowTreeHostX11::ReleaseCapture() {
   // TODO(oshima): Release x input.
 }
 
-void RootWindowHostX11::SetCursor(gfx::NativeCursor cursor) {
+void WindowTreeHostX11::SetCursor(gfx::NativeCursor cursor) {
   if (cursor == current_cursor_)
     return;
   current_cursor_ = cursor;
   SetCursorInternal(cursor);
 }
 
-bool RootWindowHostX11::QueryMouseLocation(gfx::Point* location_return) {
+bool WindowTreeHostX11::QueryMouseLocation(gfx::Point* location_return) {
   client::CursorClient* cursor_client =
       client::GetCursorClient(GetRootWindow()->window());
   if (cursor_client && !cursor_client->IsMouseEventsEnabled()) {
     *location_return = gfx::Point(0, 0);
     return false;
   }
 
   ::Window root_return, child_return;
   int root_x_return, root_y_return, win_x_return, win_y_return;
   unsigned int mask_return;
   XQueryPointer(xdisplay_,
                 xwindow_,
                 &root_return,
                 &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 RootWindowHostX11::ConfineCursorToRootWindow() {
+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_,
@@ skipping 15 matching lines @@
   // 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 RootWindowHostX11::UnConfineCursor() {
+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 RootWindowHostX11::OnCursorVisibilityChanged(bool show) {
+void WindowTreeHostX11::OnCursorVisibilityChanged(bool show) {
   SetCrOSTapPaused(!show);
 }
 
-void RootWindowHostX11::MoveCursorTo(const gfx::Point& location) {
+void WindowTreeHostX11::MoveCursorTo(const gfx::Point& location) {
   XWarpPointer(xdisplay_, None, x_root_window_, 0, 0, 0, 0,
                bounds_.x() + location.x(),
                bounds_.y() + location.y());
 }
 
-void RootWindowHostX11::PostNativeEvent(
+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:
     case LeaveNotify:
@@ skipping 12 matching lines @@
       delegate_->AsRootWindow()->host()->ConvertPointToNativeScreen(&point);
       xevent.xmotion.x_root = point.x();
       xevent.xmotion.y_root = point.y();
     }
     default:
       break;
   }
   XSendEvent(xdisplay_, xwindow_, False, 0, &xevent);
 }
 
-void RootWindowHostX11::OnDeviceScaleFactorChanged(
+void WindowTreeHostX11::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
 }
 
-void RootWindowHostX11::PrepareForShutdown() {
+void WindowTreeHostX11::PrepareForShutdown() {
   base::MessagePumpX11::Current()->RemoveDispatcherForWindow(xwindow_);
 }
 
-void RootWindowHostX11::OnWindowInitialized(Window* window) {
+void WindowTreeHostX11::OnWindowInitialized(Window* window) {
 }
 
-void RootWindowHostX11::OnRootWindowInitialized(RootWindow* root_window) {
+void WindowTreeHostX11::OnRootWindowInitialized(RootWindow* root_window) {
   // UpdateIsInternalDisplay relies on:
   // 1. delegate_ pointing to RootWindow - available after SetDelegate.
   // 2. RootWindow's kDisplayIdKey property set - available by the time
   //    RootWindow::Init is called.
   //    (set in DisplayManager::CreateRootWindowForDisplay)
   // Ready when NotifyRootWindowInitialized is called from RootWindow::Init.
   if (!delegate_ || root_window != GetRootWindow())
     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* RootWindowHostX11::GetEventProcessor() {
+ui::EventProcessor* WindowTreeHostX11::GetEventProcessor() {
   return delegate_->GetEventProcessor();
 }
 
-bool RootWindowHostX11::DispatchEventForRootWindow(
+bool WindowTreeHostX11::DispatchEventForRootWindow(
     const base::NativeEvent& event) {
   switch (event->type) {
     case GenericEvent:
       DispatchXI2Event(event);
       break;
   }
 
   return true;
 }
 
-void RootWindowHostX11::DispatchXI2Event(const base::NativeEvent& event) {
+void WindowTreeHostX11::DispatchXI2Event(const base::NativeEvent& event) {
   ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
   XEvent* xev = event;
   if (!factory->ShouldProcessXI2Event(xev))
     return;
 
-  TRACE_EVENT1("input", "RootWindowHostX11::DispatchXI2Event",
+  TRACE_EVENT1("input", "WindowTreeHostX11::DispatchXI2Event",
                "event_latency_us",
                (ui::EventTimeForNow() - ui::EventTimeFromNative(event)).
                  InMicroseconds());
 
   ui::EventType type = ui::EventTypeFromNative(xev);
   XEvent last_event;
   int num_coalesced = 0;
 
   switch (type) {
     case ui::ET_TOUCH_MOVED:
@@ skipping 105 matching lines @@
       break;
     default:
       NOTREACHED();
   }
 
   // If we coalesced an event we need to free its cookie.
   if (num_coalesced > 0)
     XFreeEventData(xev->xgeneric.display, &last_event.xcookie);
 }
 
-bool RootWindowHostX11::IsWindowManagerPresent() {
+bool WindowTreeHostX11::IsWindowManagerPresent() {
   // 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 RootWindowHostX11::SetCursorInternal(gfx::NativeCursor cursor) {
+void WindowTreeHostX11::SetCursorInternal(gfx::NativeCursor cursor) {
   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 }
 
-void RootWindowHostX11::TranslateAndDispatchMouseEvent(
+void WindowTreeHostX11::TranslateAndDispatchMouseEvent(
     ui::MouseEvent* event) {
   Window* root_window = GetRootWindow()->window();
   client::ScreenPositionClient* screen_position_client =
       client::GetScreenPositionClient(root_window);
   gfx::Rect local(bounds_.size());
 
   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);
   }
   delegate_->OnHostMouseEvent(event);
 }
 
-void RootWindowHostX11::UpdateIsInternalDisplay() {
+void WindowTreeHostX11::UpdateIsInternalDisplay() {
   Window* root_window = GetRootWindow()->window();
   gfx::Screen* screen = gfx::Screen::GetScreenFor(root_window);
   gfx::Display display = screen->GetDisplayNearestWindow(root_window);
   is_internal_display_ = display.IsInternal();
 }
 
-void RootWindowHostX11::SetCrOSTapPaused(bool state) {
+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.
@@ skipping 10 matching lines @@
         continue;
       XFree(data);
       XIChangeProperty(xdisplay_, dev_list[i].deviceid, prop, XA_INTEGER, 8,
                        PropModeReplace, &value, 1);
     }
   }
 #endif
 }
 
 // static
-RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
-  return new RootWindowHostX11(bounds);
+WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) {
+  return new WindowTreeHostX11(bounds);
 }
 
 // static
-gfx::Size RootWindowHost::GetNativeScreenSize() {
+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