Introduce RootWindowHostDelegate. The RootWindowHost performs most of its communication with RootWi…

ui/aura/root_window_host_linux.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_linux.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xcursor/Xcursor.h>
 #include <X11/Xlib.h>
 #include <X11/cursorfont.h>
@@ skipping 455 matching lines @@
   // the X Cursor and the corresponding XcursorImages. We need a pointer to the
   // images so that we can free them on destruction.
   typedef std::map<int, std::pair<Cursor, XcursorImages*> > AnimatedCursorMap;
   AnimatedCursorMap animated_cursors_;
 
   float scale_factor_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageCursors);
 };
 
-RootWindowHostLinux::RootWindowHostLinux(const gfx::Rect& bounds)
-    : root_window_(NULL),
+RootWindowHostLinux::RootWindowHostLinux(RootWindowHostDelegate* delegate,
+                                         const gfx::Rect& bounds)
+    : delegate_(delegate),
       xdisplay_(base::MessagePumpAuraX11::GetDefaultXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(ui::kCursorNull),
       cursor_shown_(true),
       bounds_(bounds),
       focus_when_shown_(false),
       pointer_barriers_(NULL),
       image_cursors_(new ImageCursors),
       atom_cache_(xdisplay_, kAtomsToCache) {
@@ skipping 86 matching lines @@
   XFreeCursor(xdisplay_, invisible_cursor_);
 }
 
 bool RootWindowHostLinux::Dispatch(const base::NativeEvent& event) {
   XEvent* xev = event;
 
   CheckXEventForConsistency(xev);
 
   switch (xev->type) {
     case Expose:
-      root_window_->ScheduleFullDraw();
+      delegate_->AsRootWindow()->ScheduleFullDraw();
       break;
     case KeyPress: {
       KeyEvent keydown_event(xev, false);
-      root_window_->DispatchKeyEvent(&keydown_event);
+      delegate_->OnHostKeyEvent(&keydown_event);
       break;
     }
     case KeyRelease: {
       KeyEvent keyup_event(xev, false);
-      root_window_->DispatchKeyEvent(&keyup_event);
+      delegate_->OnHostKeyEvent(&keyup_event);
       break;
     }
     case ButtonPress: {
       if (static_cast<int>(xev->xbutton.button) == kBackMouseButton ||
           static_cast<int>(xev->xbutton.button) == kForwardMouseButton) {
         client::UserActionClient* gesture_client =
-            client::GetUserActionClient(root_window_);
+            client::GetUserActionClient(delegate_->AsRootWindow());
         if (gesture_client) {
           gesture_client->OnUserAction(
               static_cast<int>(xev->xbutton.button) == kBackMouseButton ?
               client::UserActionClient::BACK :
               client::UserActionClient::FORWARD);
         }
         break;
       }
     }  // fallthrough
     case ButtonRelease: {
       MouseEvent mouseev(xev);
-      root_window_->DispatchMouseEvent(&mouseev);
+      delegate_->OnHostMouseEvent(&mouseev);
       break;
     }
     case FocusOut:
-      if (xev->xfocus.mode != NotifyGrab) {
-        Window* capture_window = client::GetCaptureWindow(root_window_);
-        if (capture_window && capture_window->GetRootWindow() == root_window_)
-          capture_window->ReleaseCapture();
-      }
+      if (xev->xfocus.mode != NotifyGrab)
+        delegate_->OnHostLostCapture();
       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.
       gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
                        xev->xconfigure.width, xev->xconfigure.height);
       bool size_changed = bounds_.size() != bounds.size();
       bounds_ = bounds;
       // Update barrier and mouse location when the root window has
       // moved/resized.
       if (pointer_barriers_.get()) {
         UnConfineCursor();
         gfx::Point p = gfx::Screen::GetCursorScreenPoint();
         XWarpPointer(xdisplay_, None,  xwindow_, 0, 0, 0, 0, p.x(), p.y());
         ConfineCursorToRootWindow();
       }
       if (size_changed)
-        root_window_->OnHostResized(bounds.size());
+        delegate_->OnHostResized(bounds.size());
       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_PRESSED:
         case ui::ET_TOUCH_RELEASED:
         case ui::ET_TOUCH_MOVED: {
           TouchEvent touchev(xev);
-          root_window_->DispatchTouchEvent(&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_MOUSEWHEEL:
         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 = CoalescePendingXIMotionEvents(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) {
               client::UserActionClient* gesture_client =
-                  client::GetUserActionClient(root_window_);
+                  client::GetUserActionClient(delegate_->AsRootWindow());
               if (gesture_client) {
                 bool reverse_direction =
                     ui::IsTouchpadEvent(xev) && ui::IsNaturalScrollEnabled();
                 gesture_client->OnUserAction(
                     (button == kBackMouseButton && !reverse_direction) ||
                     (button == kForwardMouseButton && reverse_direction) ?
                     client::UserActionClient::BACK :
                     client::UserActionClient::FORWARD);
               }
               break;
             }
           }
           MouseEvent mouseev(xev);
-          root_window_->DispatchMouseEvent(&mouseev);
+          delegate_->OnHostMouseEvent(&mouseev);
           break;
         }
         case ui::ET_SCROLL_FLING_START:
         case ui::ET_SCROLL_FLING_CANCEL:
         case ui::ET_SCROLL: {
           ScrollEvent scrollev(xev);
-          root_window_->DispatchScrollEvent(&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)
         XFreeEventData(xev->xgeneric.display, &last_event.xcookie);
       break;
     }
     case MapNotify: {
       // If there's no window manager running, we need to assign the X input
       // focus to our host window.
       if (!IsWindowManagerPresent() && focus_when_shown_)
         XSetInputFocus(xdisplay_, xwindow_, RevertToNone, CurrentTime);
       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.
-        root_window_->OnRootWindowHostClosed();
+        delegate_->AsRootWindow()->OnRootWindowHostClosed();
       } 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);
       }
       break;
     }
     case MappingNotify: {
       switch (xev->xmapping.request) {
         case MappingModifier:
         case MappingKeyboard:
           XRefreshKeyboardMapping(&xev->xmapping);
-          root_window_->OnKeyboardMappingChanged();
+          delegate_->AsRootWindow()->OnKeyboardMappingChanged();
           break;
         case MappingPointer:
           ui::UpdateButtonMap();
           break;
         default:
           NOTIMPLEMENTED() << " Unknown request: " << xev->xmapping.request;
           break;
       }
       break;
     }
     case MotionNotify: {
       // Discard all but the most recent motion event that targets the same
       // window with unchanged state.
       XEvent last_event;
       while (XPending(xev->xany.display)) {
         XEvent next_event;
         XPeekEvent(xev->xany.display, &next_event);
         if (next_event.type == MotionNotify &&
             next_event.xmotion.window == xev->xmotion.window &&
             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;
         }
       }
 
       MouseEvent mouseev(xev);
-      root_window_->DispatchMouseEvent(&mouseev);
+      delegate_->OnHostMouseEvent(&mouseev);
       break;
     }
   }
   return true;
 }
 
-void RootWindowHostLinux::SetRootWindow(RootWindow* root_window) {
-  root_window_ = root_window;
-  // The device scale factor is now accessible, so load cursors now.
-  image_cursors_->Reload(root_window_->layer()->device_scale_factor());
-}
-
 RootWindow* RootWindowHostLinux::GetRootWindow() {
-  return root_window_;
+  return delegate_->AsRootWindow();
 }
 
 gfx::AcceleratedWidget RootWindowHostLinux::GetAcceleratedWidget() {
   return xwindow_;
 }
 
 void RootWindowHostLinux::Show() {
+  // The device scale factor is now accessible, so load cursors now.
+  image_cursors_->Reload(delegate_->GetDeviceScaleFactor());
+
   // Before we map the window, set size hints. Otherwise, some window managers
   // will ignore toplevel XMoveWindow commands.
   XSizeHints size_hints;
   size_hints.flags = PPosition;
   size_hints.x = bounds_.x();
   size_hints.y = bounds_.y();
   XSetWMNormalHints(xdisplay_, xwindow_, &size_hints);
 
   XMapWindow(xdisplay_, xwindow_);
 }
 
 void RootWindowHostLinux::ToggleFullScreen() {
   NOTIMPLEMENTED();
 }
 
 gfx::Rect RootWindowHostLinux::GetBounds() const {
   return bounds_;
 }
 
 void RootWindowHostLinux::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 = root_window_->compositor()->device_scale_factor();
-  float new_scale =
-      gfx::Screen::GetDisplayNearestWindow(root_window_).device_scale_factor();
+  float current_scale = delegate_->GetDeviceScaleFactor();
+  float new_scale = gfx::Screen::GetDisplayNearestWindow(
+      delegate_->AsRootWindow()).device_scale_factor();
   bool size_changed = bounds_.size() != bounds.size() ||
       current_scale != new_scale;
 
   if (bounds.size() != bounds_.size())
     XResizeWindow(xdisplay_, xwindow_, bounds.width(), bounds.height());
 
   if (bounds.origin() != bounds_.origin())
     XMoveWindow(xdisplay_, xwindow_, bounds.x(), bounds.y());
 
   // 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 (size_changed)
-    root_window_->OnHostResized(bounds.size());
-  else
-    root_window_->SchedulePaintInRect(root_window_->bounds());
+  if (size_changed) {
+    delegate_->OnHostResized(bounds.size());
+  } else {
+    delegate_->AsRootWindow()->SchedulePaintInRect(
+        delegate_->AsRootWindow()->bounds());
+  }
 }
 
 gfx::Point RootWindowHostLinux::GetLocationOnNativeScreen() const {
   return bounds_.origin();
 }
 
 void RootWindowHostLinux::SetCapture() {
   // TODO(oshima): Grab x input.
 }
 
@@ skipping 162 matching lines @@
     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);
+      delegate_->AsRootWindow()->ConvertPointToNativeScreen(&point);
       xevent.xmotion.x_root = point.x();
       xevent.xmotion.y_root = point.y();
     }
     default:
       break;
   }
   XSendEvent(xdisplay_, xwindow_, False, 0, &xevent);
 }
 
 void RootWindowHostLinux::OnDeviceScaleFactorChanged(
@@ skipping 12 matching lines @@
   ::Cursor xcursor =
       image_cursors_->IsImageCursor(cursor) ?
       image_cursors_->ImageCursorFromNative(cursor) :
       (cursor == ui::kCursorNone ? invisible_cursor_ :
        (cursor == ui::kCursorCustom ? cursor.platform() :
         ui::GetXCursor(CursorShapeFromNative(cursor))));
   XDefineCursor(xdisplay_, xwindow_, xcursor);
 }
 
 // static
-RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
-  return new RootWindowHostLinux(bounds);
+RootWindowHost* RootWindowHost::Create(RootWindowHostDelegate* delegate,
+                                       const gfx::Rect& bounds) {
+  return new RootWindowHostLinux(delegate, bounds);
 }
 
 // static
 RootWindowHost* RootWindowHost::GetForAcceleratedWidget(
     gfx::AcceleratedWidget accelerated_widget) {
   return reinterpret_cast<RootWindowHost*>(
       ui::ViewProp::GetValue(accelerated_widget, kRootWindowHostLinuxKey));
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpAuraX11::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura