Snapshot of all changes to get jumbo in blink and content.

ui/views/widget/desktop_aura/desktop_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/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 456 matching lines @@
     // we don't destroy the window before the callback returned (as the caller
     // may delete ourselves on destroy and the ATL callback would still
     // dereference us when the callback returns).
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&DesktopWindowTreeHostX11::CloseNow,
                               close_widget_factory_.GetWeakPtr()));
   }
 }
 
 void DesktopWindowTreeHostX11::CloseNow() {
-  if (xwindow_ == None)
+  if (xwindow_ == X11Constants::None)
     return;
 
   ReleaseCapture();
   native_widget_delegate_->OnNativeWidgetDestroying();
 
   // If we have children, close them. Use a copy for iteration because they'll
   // remove themselves.
   std::set<DesktopWindowTreeHostX11*> window_children_copy = window_children_;
   for (std::set<DesktopWindowTreeHostX11*>::iterator it =
            window_children_copy.begin(); it != window_children_copy.end();
@@ skipping 17 matching lines @@
   // Destroy the compositor before destroying the |xwindow_| since shutdown
   // may try to swap, and the swap without a window causes an X error, which
   // causes a crash with in-process renderer.
   DestroyCompositor();
 
   open_windows().remove(xwindow_);
   // Actually free our native resources.
   if (ui::PlatformEventSource::GetInstance())
     ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
   XDestroyWindow(xdisplay_, xwindow_);
-  xwindow_ = None;
+  xwindow_ = X11Constants::None;
 
   desktop_native_widget_aura_->OnHostClosed();
 }
 
 aura::WindowTreeHost* DesktopWindowTreeHostX11::AsWindowTreeHost() {
   return this;
 }
 
 void DesktopWindowTreeHostX11::ShowWindowWithState(
     ui::WindowShowState show_state) {
@@ skipping 222 matching lines @@
     memset(&xclient, 0, sizeof(xclient));
     xclient.type = ClientMessage;
     xclient.xclient.window = xwindow_;
     xclient.xclient.message_type = gfx::GetAtom("_NET_ACTIVE_WINDOW");
     xclient.xclient.format = 32;
     xclient.xclient.data.l[0] = 1;  // Specified we are an app.
     xclient.xclient.data.l[1] = timestamp;
     // TODO(thomasanderson): if another chrome window is active, specify that in
     // data.l[2].  The EWMH spec claims this may make the WM more likely to
     // service our _NET_ACTIVE_WINDOW request.
-    xclient.xclient.data.l[2] = None;
+    xclient.xclient.data.l[2] = X11Constants::None;
     xclient.xclient.data.l[3] = 0;
     xclient.xclient.data.l[4] = 0;
 
-    XSendEvent(xdisplay_, x_root_window_, False,
+    XSendEvent(xdisplay_, x_root_window_, X11Constants::False,
                SubstructureRedirectMask | SubstructureNotifyMask, &xclient);
   } else {
     XRaiseWindow(xdisplay_, xwindow_);
     // Directly ask the X server to give focus to the window. Note that the call
     // would have raised an X error if the window is not mapped.
     auto old_error_handler = XSetErrorHandler(IgnoreX11Errors);
     XSetInputFocus(xdisplay_, xwindow_, RevertToParent, timestamp);
     // At this point, we know we will receive focus, and some
     // webdriver tests depend on a window being IsActive() immediately
     // after an Activate(), so just set this state now.
@@ skipping 32 matching lines @@
 
   // |has_window_focus_| and |has_pointer_focus_| are mutually exclusive.
   DCHECK(!has_window_focus_ || !has_pointer_focus_);
 
   return is_active;
 }
 
 void DesktopWindowTreeHostX11::Maximize() {
   if (HasWMSpecProperty("_NET_WM_STATE_FULLSCREEN")) {
     // Unfullscreen the window if it is fullscreen.
-    SetWMSpecState(false, gfx::GetAtom("_NET_WM_STATE_FULLSCREEN"), None);
+    SetWMSpecState(false, gfx::GetAtom("_NET_WM_STATE_FULLSCREEN"), X11Constants::None);
 
     // Resize the window so that it does not have the same size as a monitor.
     // (Otherwise, some window managers immediately put the window back in
     // fullscreen mode).
     gfx::Rect adjusted_bounds_in_pixels(bounds_in_pixels_.origin(),
                                         AdjustSize(bounds_in_pixels_.size()));
     if (adjusted_bounds_in_pixels != bounds_in_pixels_)
       SetBoundsInPixels(adjusted_bounds_in_pixels);
   }
 
@@ skipping 33 matching lines @@
 bool DesktopWindowTreeHostX11::IsMinimized() const {
   return HasWMSpecProperty("_NET_WM_STATE_HIDDEN");
 }
 
 bool DesktopWindowTreeHostX11::HasCapture() const {
   return g_current_capture == this;
 }
 
 void DesktopWindowTreeHostX11::SetAlwaysOnTop(bool always_on_top) {
   is_always_on_top_ = always_on_top;
-  SetWMSpecState(always_on_top, gfx::GetAtom("_NET_WM_STATE_ABOVE"), None);
+  SetWMSpecState(always_on_top, gfx::GetAtom("_NET_WM_STATE_ABOVE"), X11Constants::None);
 }
 
 bool DesktopWindowTreeHostX11::IsAlwaysOnTop() const {
   return is_always_on_top_;
 }
 
 void DesktopWindowTreeHostX11::SetVisibleOnAllWorkspaces(bool always_visible) {
-  SetWMSpecState(always_visible, gfx::GetAtom("_NET_WM_STATE_STICKY"), None);
+  SetWMSpecState(always_visible, gfx::GetAtom("_NET_WM_STATE_STICKY"), X11Constants::None);
 
   int new_desktop = 0;
   if (always_visible) {
     new_desktop = kAllDesktops;
   } else {
     if (!ui::GetCurrentDesktop(&new_desktop))
       return;
   }
 
   workspace_ = base::IntToString(kAllDesktops);
   XEvent xevent;
   memset (&xevent, 0, sizeof (xevent));
   xevent.type = ClientMessage;
   xevent.xclient.window = xwindow_;
   xevent.xclient.message_type = gfx::GetAtom("_NET_WM_DESKTOP");
   xevent.xclient.format = 32;
   xevent.xclient.data.l[0] = new_desktop;
   xevent.xclient.data.l[1] = 0;
   xevent.xclient.data.l[2] = 0;
   xevent.xclient.data.l[3] = 0;
   xevent.xclient.data.l[4] = 0;
-  XSendEvent(xdisplay_, x_root_window_, False,
-             SubstructureRedirectMask | SubstructureNotifyMask,
-             &xevent);
+  XSendEvent(xdisplay_, x_root_window_, X11Constants::False,
+             SubstructureRedirectMask | SubstructureNotifyMask, &xevent);
 }
 
 bool DesktopWindowTreeHostX11::IsVisibleOnAllWorkspaces() const {
   // We don't need a check for _NET_WM_STATE_STICKY because that would specify
   // that the window remain in a fixed position even if the viewport scrolls.
   // This is different from the type of workspace that's associated with
   // _NET_WM_DESKTOP.
   return GetWorkspace() == base::IntToString(kAllDesktops);
 }
 
 bool DesktopWindowTreeHostX11::SetWindowTitle(const base::string16& title) {
   if (window_title_ == title)
     return false;
   window_title_ = title;
   std::string utf8str = base::UTF16ToUTF8(title);
   XChangeProperty(xdisplay_, xwindow_, gfx::GetAtom("_NET_WM_NAME"),
                   gfx::GetAtom("UTF8_STRING"), 8, PropModeReplace,
                   reinterpret_cast<const unsigned char*>(utf8str.c_str()),
                   utf8str.size());
   XTextProperty xtp;
   char* c_utf8_str = const_cast<char*>(utf8str.c_str());
-  if (Xutf8TextListToTextProperty(xdisplay_, &c_utf8_str, 1,
-                                  XUTF8StringStyle, &xtp) == Success) {
+  if (Xutf8TextListToTextProperty(xdisplay_, &c_utf8_str, 1, XUTF8StringStyle,
+                                  &xtp) == X11Constants::Success) {
     XSetWMName(xdisplay_, xwindow_, &xtp);
     XFree(xtp.value);
   }
   return true;
 }
 
 void DesktopWindowTreeHostX11::ClearNativeFocus() {
   // This method is weird and misnamed. Instead of clearing the native focus,
   // it sets the focus to our |content_window_|, which will trigger a cascade
   // of focus changes into views.
@@ skipping 70 matching lines @@
 
   // Work around a bug where if we try to unfullscreen, metacity immediately
   // fullscreens us again. This is a little flickery and not necessary if
   // there's a gnome-panel, but it's not easy to detect whether there's a
   // panel or not.
   bool unmaximize_and_remaximize = !fullscreen && IsMaximized() &&
                                    ui::GuessWindowManager() == ui::WM_METACITY;
 
   if (unmaximize_and_remaximize)
     Restore();
-  SetWMSpecState(fullscreen, gfx::GetAtom("_NET_WM_STATE_FULLSCREEN"), None);
+  SetWMSpecState(fullscreen, gfx::GetAtom("_NET_WM_STATE_FULLSCREEN"), X11Constants::None);
   if (unmaximize_and_remaximize)
     Maximize();
 
   // Try to guess the size we will have after the switch to/from fullscreen:
   // - (may) avoid transient states
   // - works around Flash content which expects to have the size updated
   //   synchronously.
   // See https://crbug.com/361408
   if (fullscreen) {
     restored_bounds_in_pixels_ = bounds_in_pixels_;
@@ skipping 238 matching lines @@
   DesktopWindowTreeHostX11* old_capturer = g_current_capture;
 
   // Update |g_current_capture| prior to calling OnHostLostWindowCapture() to
   // avoid releasing pointer grab.
   g_current_capture = this;
   if (old_capturer)
     old_capturer->OnHostLostWindowCapture();
 
   // If the pointer is already in |xwindow_|, we will not get a crossing event
   // with a mode of NotifyGrab, so we must record the grab state manually.
-  has_pointer_grab_ |= !GrabPointer(xwindow_, true, None);
+  has_pointer_grab_ |= !GrabPointer(xwindow_, true, X11Constants::None);
 }
 
 void DesktopWindowTreeHostX11::ReleaseCapture() {
   if (g_current_capture == this) {
     // Release mouse grab asynchronously. A window managed by Chrome is likely
     // the topmost window underneath the mouse so the capture release being
     // asynchronous is likely inconsequential.
     g_current_capture = NULL;
     UngrabPointer();
     has_pointer_grab_ = false;
 
     OnHostLostWindowCapture();
   }
 }
 
 void DesktopWindowTreeHostX11::SetCursorNative(gfx::NativeCursor cursor) {
   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 }
 
 void DesktopWindowTreeHostX11::MoveCursorToScreenLocationInPixels(
     const gfx::Point& location_in_pixels) {
-  XWarpPointer(xdisplay_, None, x_root_window_, 0, 0, 0, 0,
+  XWarpPointer(xdisplay_, X11Constants::None, x_root_window_, 0, 0, 0, 0,
                bounds_in_pixels_.x() + location_in_pixels.x(),
                bounds_in_pixels_.y() + location_in_pixels.y());
 }
 
 void DesktopWindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
   // TODO(erg): Conditional on us enabling touch on desktop linux builds, do
   // the same tap-to-click disabling here that chromeos does.
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 19 matching lines @@
 void DesktopWindowTreeHostX11::OnMaximizedStateChanged() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostX11, private:
 
 void DesktopWindowTreeHostX11::InitX11Window(
     const Widget::InitParams& params) {
   unsigned long attribute_mask = CWBackPixmap | CWBitGravity;
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
-  swa.background_pixmap = None;
+  swa.background_pixmap = X11Constants::None;
   swa.bit_gravity = NorthWestGravity;
 
   ::Atom window_type;
   switch (params.type) {
     case Widget::InitParams::TYPE_MENU:
-      swa.override_redirect = True;
+      swa.override_redirect = X11Constants::True;
       window_type = gfx::GetAtom("_NET_WM_WINDOW_TYPE_MENU");
       break;
     case Widget::InitParams::TYPE_TOOLTIP:
-      swa.override_redirect = True;
+      swa.override_redirect = X11Constants::True;
       window_type = gfx::GetAtom("_NET_WM_WINDOW_TYPE_TOOLTIP");
       break;
     case Widget::InitParams::TYPE_POPUP:
-      swa.override_redirect = True;
+      swa.override_redirect = X11Constants::True;
       window_type = gfx::GetAtom("_NET_WM_WINDOW_TYPE_NOTIFICATION");
       break;
     case Widget::InitParams::TYPE_DRAG:
-      swa.override_redirect = True;
+      swa.override_redirect = X11Constants::True;
       window_type = gfx::GetAtom("_NET_WM_WINDOW_TYPE_DND");
       break;
     default:
       window_type = gfx::GetAtom("_NET_WM_WINDOW_TYPE_NORMAL");
       break;
   }
   // An in-activatable window should not interact with the system wm.
   if (!activatable_)
-    swa.override_redirect = True;
+    swa.override_redirect = X11Constants::True;
 
   if (swa.override_redirect)
     attribute_mask |= CWOverrideRedirect;
 
   bool enable_transparent_visuals;
   switch (params.opacity) {
     case Widget::InitParams::OPAQUE_WINDOW:
       enable_transparent_visuals = false;
       break;
     case Widget::InitParams::TRANSLUCENT_WINDOW:
@@ skipping 332 matching lines @@
   xclient.xclient.window = xwindow_;
   xclient.xclient.message_type = gfx::GetAtom("_NET_WM_STATE");
   xclient.xclient.format = 32;
   xclient.xclient.data.l[0] =
       enabled ? k_NET_WM_STATE_ADD : k_NET_WM_STATE_REMOVE;
   xclient.xclient.data.l[1] = state1;
   xclient.xclient.data.l[2] = state2;
   xclient.xclient.data.l[3] = 1;
   xclient.xclient.data.l[4] = 0;
 
-  XSendEvent(xdisplay_, x_root_window_, False,
-             SubstructureRedirectMask | SubstructureNotifyMask,
-             &xclient);
+  XSendEvent(xdisplay_, x_root_window_, X11Constants::False,
+             SubstructureRedirectMask | SubstructureNotifyMask, &xclient);
 }
 
 bool DesktopWindowTreeHostX11::HasWMSpecProperty(const char* property) const {
   return window_properties_.find(gfx::GetAtom(property)) !=
          window_properties_.end();
 }
 
 void DesktopWindowTreeHostX11::SetUseNativeFrame(bool use_native_frame) {
   use_native_frame_ = use_native_frame;
   ui::SetUseOSWindowFrame(xwindow_, use_native_frame);
@@ skipping 97 matching lines @@
     }
   }
 
   // If we didn't set the shape for any reason, reset the shaping information.
   // How this is done depends on the border style, due to quirks and bugs in
   // various window managers.
   if (ShouldUseNativeFrame()) {
     // If the window has system borders, the mask must be set to null (not a
     // rectangle), because several window managers (eg, KDE, XFCE, XMonad) will
     // not put borders on a window with a custom shape.
-    XShapeCombineMask(xdisplay_, xwindow_, ShapeBounding, 0, 0, None, ShapeSet);
+    XShapeCombineMask(xdisplay_, xwindow_, ShapeBounding, 0, 0,
+                      X11Constants::None, ShapeSet);
   } else {
     // Conversely, if the window does not have system borders, the mask must be
     // manually set to a rectangle that covers the whole window (not null). This
     // is due to a bug in KWin <= 4.11.5 (KDE bug #330573) where setting a null
     // shape causes the hint to disable system borders to be ignored (resulting
     // in a double border).
     XRectangle r = {0,
                     0,
                     static_cast<unsigned short>(bounds_in_pixels_.width()),
                     static_cast<unsigned short>(bounds_in_pixels_.height())};
@@ skipping 311 matching lines @@
       Atom message_type = xev->xclient.message_type;
       if (message_type == gfx::GetAtom("WM_PROTOCOLS")) {
         Atom protocol = static_cast<Atom>(xev->xclient.data.l[0]);
         if (protocol == gfx::GetAtom("WM_DELETE_WINDOW")) {
           // We have received a close message from the window manager.
           OnHostCloseRequested();
         } else if (protocol == gfx::GetAtom("_NET_WM_PING")) {
           XEvent reply_event = *xev;
           reply_event.xclient.window = x_root_window_;
 
-          XSendEvent(xdisplay_,
-                     reply_event.xclient.window,
-                     False,
+          XSendEvent(xdisplay_, reply_event.xclient.window, X11Constants::False,
                      SubstructureRedirectMask | SubstructureNotifyMask,
                      &reply_event);
         }
       } else if (message_type == gfx::GetAtom("XdndEnter")) {
         drag_drop_client_->OnXdndEnter(xev->xclient);
       } else if (message_type == gfx::GetAtom("XdndLeave")) {
         drag_drop_client_->OnXdndLeave(xev->xclient);
       } else if (message_type == gfx::GetAtom("XdndPosition")) {
         drag_drop_client_->OnXdndPosition(xev->xclient);
       } else if (message_type == gfx::GetAtom("XdndStatus")) {
@@ skipping 147 matching lines @@
 
 // static
 DesktopWindowTreeHost* DesktopWindowTreeHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura) {
   return new DesktopWindowTreeHostX11(native_widget_delegate,
                                       desktop_native_widget_aura);
 }
 
 }  // namespace views