Remove some pass-thrus on RootWindow API in favor of exposing the RootWindowHost again.

ui/views/widget/desktop_aura/desktop_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/views/widget/desktop_aura/desktop_root_window_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 114 matching lines @@
       atom_cache_(xdisplay_, kAtomsToCache),
       window_mapped_(false),
       focus_when_shown_(false),
       is_fullscreen_(false),
       is_always_on_top_(false),
       root_window_(NULL),
       drag_drop_client_(NULL),
       current_cursor_(ui::kCursorNull),
       native_widget_delegate_(native_widget_delegate),
       desktop_native_widget_aura_(desktop_native_widget_aura),
-      root_window_host_delegate_(NULL),
       content_window_(NULL),
       window_parent_(NULL) {
 }
 
 DesktopRootWindowHostX11::~DesktopRootWindowHostX11() {
   root_window_->window()->ClearProperty(kHostForRootWindow);
   aura::client::SetWindowMoveClient(root_window_->window(), NULL);
   desktop_native_widget_aura_->OnDesktopRootWindowHostDestroyed(root_window_);
 }
 
@@ skipping 19 matching lines @@
   return windows;
 }
 
 gfx::Rect DesktopRootWindowHostX11::GetX11RootWindowBounds() const {
   return bounds_;
 }
 
 void DesktopRootWindowHostX11::HandleNativeWidgetActivationChanged(
     bool active) {
   if (active)
-    root_window_host_delegate_->OnHostActivated();
+    delegate_->OnHostActivated();
 
   desktop_native_widget_aura_->HandleActivationChanged(active);
 
   native_widget_delegate_->AsWidget()->GetRootView()->SchedulePaint();
 }
 
 void DesktopRootWindowHostX11::AddObserver(
     views::DesktopRootWindowHostObserverX11* observer) {
   observer_list_.AddObserver(observer);
 }
@@ skipping 35 matching lines @@
 }
 
 void DesktopRootWindowHostX11::OnRootWindowCreated(
     aura::RootWindow* root,
     const Widget::InitParams& params) {
   root_window_ = root;
 
   root_window_->window()->SetProperty(kViewsWindowForRootWindow,
                                       content_window_);
   root_window_->window()->SetProperty(kHostForRootWindow, this);
-  root_window_host_delegate_ = root_window_;
+  delegate_ = root_window_;
 
   // If we're given a parent, we need to mark ourselves as transient to another
   // window. Otherwise activation gets screwy.
   gfx::NativeView parent = params.parent;
   if (!params.child && params.parent)
     parent->AddTransientChild(content_window_);
 
   // Ensure that the X11DesktopHandler exists so that it dispatches activation
   // messages to us.
   X11DesktopHandler::get();
@@ skipping 434 matching lines @@
     native_widget_delegate_->AsWidget()->GetInputMethod()->OnBlur();
 }
 
 bool DesktopRootWindowHostX11::IsAnimatingClosed() const {
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopRootWindowHostX11, aura::RootWindowHost implementation:
 
-void DesktopRootWindowHostX11::SetDelegate(
-    aura::RootWindowHostDelegate* delegate) {
-  root_window_host_delegate_ = delegate;
-}
-
 aura::RootWindow* DesktopRootWindowHostX11::GetRootWindow() {
   return root_window_;
 }
 
 gfx::AcceleratedWidget DesktopRootWindowHostX11::GetAcceleratedWidget() {
   return xwindow_;
 }
 
 void DesktopRootWindowHostX11::Show() {
   if (!window_mapped_) {
@@ skipping 57 matching lines @@
   // 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;
 
   if (origin_changed)
     native_widget_delegate_->AsWidget()->OnNativeWidgetMove();
   if (size_changed)
-    root_window_host_delegate_->OnHostResized(bounds.size());
+    delegate_->OnHostResized(bounds.size());
   else
-    root_window_host_delegate_->OnHostPaint(gfx::Rect(bounds.size()));
+    delegate_->OnHostPaint(gfx::Rect(bounds.size()));
 }
 
 gfx::Insets DesktopRootWindowHostX11::GetInsets() const {
   return gfx::Insets();
 }
 
 void DesktopRootWindowHostX11::SetInsets(const gfx::Insets& insets) {
 }
 
 gfx::Point DesktopRootWindowHostX11::GetLocationOnNativeScreen() const {
@@ skipping 69 matching lines @@
 void DesktopRootWindowHostX11::OnCursorVisibilityChanged(bool show) {
   // TODO(erg): Conditional on us enabling touch on desktop linux builds, do
   // the same tap-to-click disabling here that chromeos does.
 }
 
 void DesktopRootWindowHostX11::MoveCursorTo(const gfx::Point& location) {
   XWarpPointer(xdisplay_, None, x_root_window_, 0, 0, 0, 0,
                bounds_.x() + location.x(), bounds_.y() + location.y());
 }
 
-void DesktopRootWindowHostX11::SetFocusWhenShown(bool focus_when_shown) {
-  static const char* k_NET_WM_USER_TIME = "_NET_WM_USER_TIME";
-  focus_when_shown_ = focus_when_shown;
-  if (IsWindowManagerPresent() && !focus_when_shown_) {
-    ui::SetIntProperty(xwindow_,
-                       k_NET_WM_USER_TIME,
-                       k_NET_WM_USER_TIME,
-                       0);
-  }
-}
-
 void DesktopRootWindowHostX11::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:
     case MotionNotify:
     case KeyPress:
     case KeyRelease:
     case ButtonPress:
     case ButtonRelease: {
       // The fields used below are in the same place for all of events
       // above. Using xmotion from XEvent's unions to avoid repeating
       // the code.
       xevent.xmotion.root = x_root_window_;
       xevent.xmotion.time = CurrentTime;
 
       gfx::Point point(xevent.xmotion.x, xevent.xmotion.y);
-      root_window_->ConvertPointToNativeScreen(&point);
+      ConvertPointToNativeScreen(&point);
       xevent.xmotion.x_root = point.x();
       xevent.xmotion.y_root = point.y();
     }
     default:
       break;
   }
   XSendEvent(xdisplay_, xwindow_, False, 0, &xevent);
 }
 
 void DesktopRootWindowHostX11::OnDeviceScaleFactorChanged(
@@ skipping 122 matching lines @@
 
   if (!params.wm_class_name.empty() || !params.wm_class_class.empty()) {
     ui::SetWindowClassHint(
         xdisplay_, xwindow_, params.wm_class_name, params.wm_class_class);
   }
 
   // If we have a parent, record the parent/child relationship. We use this
   // data during destruction to make sure that when we try to close a parent
   // window, we also destroy all child windows.
   if (params.parent && params.parent->GetDispatcher()) {
-    XID parent_xid = params.parent->GetDispatcher()->GetAcceleratedWidget();
+    XID parent_xid =
+        params.parent->GetDispatcher()->host()->GetAcceleratedWidget();
     window_parent_ = GetHostForXID(parent_xid);
     DCHECK(window_parent_);
     window_parent_->window_children_.insert(this);
   }
 
   // If we have a delegate which is providing a default window icon, use that
   // icon.
   gfx::ImageSkia* window_icon = ViewsDelegate::views_delegate ?
       ViewsDelegate::views_delegate->GetDefaultWindowIcon() : NULL;
   if (window_icon) {
@@ skipping 29 matching lines @@
              &xclient);
 }
 
 bool DesktopRootWindowHostX11::HasWMSpecProperty(const char* property) const {
   return window_properties_.find(atom_cache_.GetAtom(property)) !=
       window_properties_.end();
 }
 
 void DesktopRootWindowHostX11::OnCaptureReleased() {
   g_current_capture = NULL;
-  root_window_host_delegate_->OnHostLostWindowCapture();
+  delegate_->OnHostLostWindowCapture();
   native_widget_delegate_->OnMouseCaptureLost();
 }
 
 void DesktopRootWindowHostX11::DispatchMouseEvent(ui::MouseEvent* event) {
   if (!g_current_capture || g_current_capture == this) {
-    root_window_host_delegate_->OnHostMouseEvent(event);
+    delegate_->OnHostMouseEvent(event);
   } else {
     // Another DesktopRootWindowHostX11 has installed itself as
     // capture. Translate the event's location and dispatch to the other.
     event->ConvertLocationToTarget(root_window_->window(),
                                    g_current_capture->root_window_->window());
-    g_current_capture->root_window_host_delegate_->OnHostMouseEvent(event);
+    g_current_capture->delegate_->OnHostMouseEvent(event);
   }
 }
 
 void DesktopRootWindowHostX11::ResetWindowRegion() {
   if (!IsMaximized()) {
     gfx::Path window_mask;
     views::Widget* widget = native_widget_delegate_->AsWidget();
     if (widget->non_client_view()) {
       // Some frame views define a custom (non-rectangular) window mask. If
       // so, use it to define the window shape. If not, fall through.
@@ skipping 55 matching lines @@
     case LeaveNotify: {
       if (!g_current_capture)
         X11DesktopHandler::get()->ProcessXEvent(xev);
       ui::MouseEvent mouse_event(xev);
       DispatchMouseEvent(&mouse_event);
       break;
     }
     case Expose: {
       gfx::Rect damage_rect(xev->xexpose.x, xev->xexpose.y,
                             xev->xexpose.width, xev->xexpose.height);
-      root_window_host_delegate_->OnHostPaint(damage_rect);
+      delegate_->OnHostPaint(damage_rect);
       break;
     }
     case KeyPress: {
       ui::KeyEvent keydown_event(xev, false);
-      root_window_host_delegate_->OnHostKeyEvent(&keydown_event);
+      delegate_->OnHostKeyEvent(&keydown_event);
       break;
     }
     case KeyRelease: {
       ui::KeyEvent keyup_event(xev, false);
-      root_window_host_delegate_->OnHostKeyEvent(&keyup_event);
+      delegate_->OnHostKeyEvent(&keyup_event);
       break;
     }
     case ButtonPress: {
       if (static_cast<int>(xev->xbutton.button) == kBackMouseButton ||
           static_cast<int>(xev->xbutton.button) == kForwardMouseButton) {
         aura::client::UserActionClient* gesture_client =
             aura::client::GetUserActionClient(root_window_->window());
         if (gesture_client) {
           gesture_client->OnUserAction(
               static_cast<int>(xev->xbutton.button) == kBackMouseButton ?
@@ skipping 21 matching lines @@
           // No event is created for X11-release events for mouse-wheel buttons.
           break;
         default:
           NOTREACHED() << event_type;
       }
       break;
     }
     case FocusOut:
       if (xev->xfocus.mode != NotifyGrab) {
         ReleaseCapture();
-        root_window_host_delegate_->OnHostLostWindowCapture();
+        delegate_->OnHostLostWindowCapture();
       } else {
-        root_window_host_delegate_->OnHostLostMouseGrab();
+        delegate_->OnHostLostMouseGrab();
       }
       break;
     case ConfigureNotify: {
       DCHECK_EQ(xwindow_, xev->xconfigure.window);
       DCHECK_EQ(xwindow_, xev->xconfigure.event);
       // 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.
       int translated_x = xev->xconfigure.x;
       int translated_y = xev->xconfigure.y;
       if (!xev->xconfigure.send_event && !xev->xconfigure.override_redirect) {
         Window unused;
         XTranslateCoordinates(xdisplay_, xwindow_, x_root_window_,
             0, 0, &translated_x, &translated_y, &unused);
       }
       gfx::Rect bounds(translated_x, translated_y,
                        xev->xconfigure.width, xev->xconfigure.height);
       bool size_changed = bounds_.size() != bounds.size();
       bool origin_changed = bounds_.origin() != bounds.origin();
       previous_bounds_ = bounds_;
       bounds_ = bounds;
       if (size_changed)
-        root_window_host_delegate_->OnHostResized(bounds.size());
+        delegate_->OnHostResized(bounds.size());
       if (origin_changed)
-        root_window_host_delegate_->OnHostMoved(bounds_.origin());
+        delegate_->OnHostMoved(bounds_.origin());
       ResetWindowRegion();
       break;
     }
     case GenericEvent: {
       ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
       if (!factory->ShouldProcessXI2Event(xev))
         break;
 
       ui::EventType type = ui::EventTypeFromNative(xev);
       XEvent last_event;
       int num_coalesced = 0;
 
       switch (type) {
         // case ui::ET_TOUCH_MOVED:
         //   num_coalesced = CoalescePendingMotionEvents(xev, &last_event);
         //   if (num_coalesced > 0)
         //     xev = &last_event;
         //   // fallthrough
         // case ui::ET_TOUCH_PRESSED:
         // case ui::ET_TOUCH_RELEASED: {
         //   ui::TouchEvent touchev(xev);
-        //   root_window_host_delegate_->OnHostTouchEvent(&touchev);
+        //   delegate_->OnHostTouchEvent(&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;
           } else if (type == ui::ET_MOUSE_PRESSED) {
             XIDeviceEvent* xievent =
                 static_cast<XIDeviceEvent*>(xev->xcookie.data);
             int button = xievent->detail;
             if (button == kBackMouseButton || button == kForwardMouseButton) {
               aura::client::UserActionClient* gesture_client =
                   aura::client::GetUserActionClient(
-                      root_window_host_delegate_->AsRootWindow()->window());
+                      delegate_->AsRootWindow()->window());
               if (gesture_client) {
                 bool reverse_direction =
                     ui::IsTouchpadEvent(xev) && ui::IsNaturalScrollEnabled();
                 gesture_client->OnUserAction(
                     (button == kBackMouseButton && !reverse_direction) ||
                     (button == kForwardMouseButton && reverse_direction) ?
                     aura::client::UserActionClient::BACK :
                     aura::client::UserActionClient::FORWARD);
               }
               break;
@@ skipping 14 matching lines @@
         }
         case ui::ET_MOUSEWHEEL: {
           ui::MouseWheelEvent mouseev(xev);
           DispatchMouseEvent(&mouseev);
           break;
         }
         case ui::ET_SCROLL_FLING_START:
         case ui::ET_SCROLL_FLING_CANCEL:
         case ui::ET_SCROLL: {
           ui::ScrollEvent scrollev(xev);
-          root_window_host_delegate_->OnHostScrollEvent(&scrollev);
+          delegate_->OnHostScrollEvent(&scrollev);
           break;
         }
         case ui::ET_UNKNOWN:
           break;
         default:
           NOTREACHED();
       }
 
       // If we coalesced an event we need to free its cookie.
       if (num_coalesced > 0)
@@ skipping 159 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme();
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views