aura: Add X11 host window management.

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>
 #include <X11/extensions/XInput2.h>
+#include <X11/extensions/Xcomposite.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/Xrandr.h>
+#include <X11/extensions/shape.h>
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/message_pump_aurax11.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "grit/ui_resources.h"
+#include "ui/aura/aura_switches.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/user_action_client.h"
 #include "ui/aura/dispatcher_linux.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/touch/touch_factory.h"
@@ skipping 438 matching lines @@
 
   float scale_factor_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageCursors);
 };
 
 RootWindowHostLinux::RootWindowHostLinux(const gfx::Rect& bounds)
     : root_window_(NULL),
       xdisplay_(base::MessagePumpAuraX11::GetDefaultXDisplay()),
       xwindow_(0),
+      x_output_window_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(ui::kCursorNull),
       cursor_shown_(true),
       bounds_(bounds),
-      focus_when_shown_(false),
+      focus_when_shown_(true),
       pointer_barriers_(NULL),
       image_cursors_(new ImageCursors),
       atom_cache_(xdisplay_, kAtomsToCache) {
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
-  xwindow_ = XCreateWindow(
-      xdisplay_, x_root_window_,
-      bounds.x(), bounds.y(), bounds.width(), bounds.height(),
-      0,               // border width
-      CopyFromParent,  // depth
-      InputOutput,
-      CopyFromParent,  // visual
-      CWBackPixmap,
-      &swa);
+  long output_event_mask = ExposureMask | VisibilityChangeMask;
+  long input_event_mask = ButtonPressMask | ButtonReleaseMask |
+                          FocusChangeMask | KeyPressMask | KeyReleaseMask |
+                          EnterWindowMask | LeaveWindowMask |
+                          StructureNotifyMask | PropertyChangeMask |
+                          PointerMotionMask;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+        switches::kAuraHostWindowUseFullscreen)) {
+    x_output_window_ = XCompositeGetOverlayWindow(xdisplay_, x_root_window_);
+    XserverRegion region = XFixesCreateRegion(xdisplay_, NULL, 0);
+    XFixesSetWindowShapeRegion(
+        xdisplay_, x_output_window_, ShapeInput, 0, 0, region);
+    XFixesDestroyRegion(xdisplay_, region);
+    XSelectInput(xdisplay_, x_output_window_, output_event_mask);
+    static_cast<DispatcherLinux*>(Env::GetInstance()->GetDispatcher())->
+        AddDispatcherForWindow(this, x_output_window_);
+    xwindow_ = XCreateWindow(
+        xdisplay_, x_root_window_,
+        bounds.x(), bounds.y(), bounds.width(), bounds.height(),
+        0,               // border width
+        CopyFromParent,  // depth
+        InputOnly,
+        CopyFromParent,  // visual
+        0,
+        0);
+    XSelectInput(xdisplay_, xwindow_, input_event_mask);
+  } else {
+    x_output_window_ = xwindow_ = XCreateWindow(
+        xdisplay_, x_root_window_,
+        bounds.x(), bounds.y(), bounds.width(), bounds.height(),
+        0,               // border width
+        CopyFromParent,  // depth
+        InputOutput,
+        CopyFromParent,  // visual
+        CWBackPixmap,
+        &swa);
+    XSelectInput(xdisplay_, xwindow_, input_event_mask | output_event_mask);
+  }
   static_cast<DispatcherLinux*>(Env::GetInstance()->GetDispatcher())->
       AddDispatcherForWindow(this, xwindow_);
 
   prop_.reset(new ui::ViewProp(xwindow_, kRootWindowHostLinuxKey, this));
 
-  long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
-                    KeyPressMask | KeyReleaseMask |
-                    EnterWindowMask | LeaveWindowMask |
-                    ExposureMask | VisibilityChangeMask |
-                    StructureNotifyMask | PropertyChangeMask |
-                    PointerMotionMask;
-  XSelectInput(xdisplay_, xwindow_, event_mask);
   XFlush(xdisplay_);
 
   if (base::MessagePumpForUI::HasXInput2())
     ui::TouchFactory::GetInstance()->SetupXI2ForXWindow(xwindow_);
 
   // Initialize invisible cursor.
   char nodata[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   XColor black;
   black.red = black.green = black.blue = 0;
-  Pixmap blank = XCreateBitmapFromData(xdisplay_, xwindow_,
+  Pixmap blank = XCreateBitmapFromData(xdisplay_, x_output_window_,
                                        nodata, 8, 8);
   invisible_cursor_ = XCreatePixmapCursor(xdisplay_, blank, blank,
                                           &black, &black, 0, 0);
   XFreePixmap(xdisplay_, blank);
 
   if (RootWindow::hide_host_cursor())
     XDefineCursor(xdisplay_, x_root_window_, invisible_cursor_);
 
   // TODO(erg): We currently only request window deletion events. We also
   // should listen for activation events and anything else that GTK+ listens
@@ skipping 29 matching lines @@
 }
 
 RootWindowHostLinux::~RootWindowHostLinux() {
   static_cast<DispatcherLinux*>(Env::GetInstance()->GetDispatcher())->
       RemoveDispatcherForWindow(xwindow_);
 
   UnConfineCursor();
 
   XDestroyWindow(xdisplay_, xwindow_);
 
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+        switches::kAuraHostWindowUseFullscreen))
+    XCompositeReleaseOverlayWindow(xdisplay_, x_root_window_);
+
   // Clears XCursorCache.
   ui::GetXCursor(ui::kCursorClearXCursorCache);
 
   XFreeCursor(xdisplay_, invisible_cursor_);
 }
 
 bool RootWindowHostLinux::Dispatch(const base::NativeEvent& event) {
   XEvent* xev = event;
 
   CheckXEventForConsistency(xev);
@@ skipping 201 matching lines @@
   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_;
 }
 
 gfx::AcceleratedWidget RootWindowHostLinux::GetAcceleratedWidget() {
+  return x_output_window_;
+}
+
+gfx::AcceleratedWidget RootWindowHostLinux::
+    GetAcceleratedWidgetUsedForEvents() {
   return xwindow_;
 }
 
 void RootWindowHostLinux::Show() {
   // 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();
@@ skipping 17 matching lines @@
   float new_scale =
       gfx::Screen::GetDisplayNearestWindow(root_window_).device_scale_factor();
   bool size_changed = bounds_.size() != bounds.size() ||
       current_scale != new_scale;
 
   if (!size_changed) {
     root_window_->SchedulePaintInRect(root_window_->bounds());
     return;
   }
 
-  if (bounds.size() != bounds_.size())
+  if (bounds.size() != bounds_.size()) {
     XResizeWindow(xdisplay_, xwindow_, bounds.width(), bounds.height());
+    if (x_output_window_ != xwindow_)
+      XResizeWindow(
+          xdisplay_, x_output_window_, bounds.width(), bounds.height());
+  }
 
-  if (bounds.origin() != bounds_.origin())
+  if (bounds.origin() != bounds_.origin()) {
     XMoveWindow(xdisplay_, xwindow_, bounds.x(), bounds.y());
+    if (x_output_window_ != xwindow_)
+      XMoveWindow(xdisplay_, x_output_window_, 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());
 }
@@ skipping 103 matching lines @@
                        k_NET_WM_USER_TIME,
                        k_NET_WM_USER_TIME,
                        0);
   }
 }
 
 bool RootWindowHostLinux::GrabSnapshot(
     const gfx::Rect& snapshot_bounds,
     std::vector<unsigned char>* png_representation) {
   XImage* image = XGetImage(
-      xdisplay_, xwindow_,
+      xdisplay_, x_output_window_,
       snapshot_bounds.x(), snapshot_bounds.y(),
       snapshot_bounds.width(), snapshot_bounds.height(),
       AllPlanes, ZPixmap);
 
   if (!image) {
     LOG(ERROR) << "XGetImage failed";
     return false;
   }
 
   gfx::PNGCodec::ColorFormat color_format;
@@ skipping 60 matching lines @@
       break;
   }
   XSendEvent(xdisplay_, xwindow_, False, 0, &xevent);
 }
 
 void RootWindowHostLinux::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   image_cursors_->Reload(device_scale_factor);
 }
 
+bool RootWindowHostLinux::DispatchNativeEvent(
+    const base::NativeEvent& native_event) {
+  return Dispatch(native_event);
+}
+
 bool RootWindowHostLinux::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 RootWindowHostLinux::SetCursorInternal(gfx::NativeCursor cursor) {
   ::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);
+  if (x_output_window_ != xwindow_)
+    XDefineCursor(xdisplay_, x_root_window_, xcursor);
+  else
+    XDefineCursor(xdisplay_, xwindow_, xcursor);
+  GetRootWindow()->OnCursorChanged(xcursor);
 }
 
 // static
 RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
   return new RootWindowHostLinux(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