Revert of Fix X11TopmostWindowFinder

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 58 matching lines @@
 namespace {
 
 // Constants that are part of EWMH.
 const int k_NET_WM_STATE_ADD = 1;
 const int k_NET_WM_STATE_REMOVE = 0;
 
 const char* kAtomsToCache[] = {
   "UTF8_STRING",
   "WM_DELETE_WINDOW",
   "WM_PROTOCOLS",
-  "_NET_FRAME_EXTENTS",
   "_NET_WM_CM_S0",
   "_NET_WM_ICON",
   "_NET_WM_NAME",
   "_NET_WM_PID",
   "_NET_WM_PING",
   "_NET_WM_STATE",
   "_NET_WM_STATE_ABOVE",
   "_NET_WM_STATE_FULLSCREEN",
   "_NET_WM_STATE_HIDDEN",
   "_NET_WM_STATE_MAXIMIZED_HORZ",
@@ skipping 44 matching lines @@
       is_fullscreen_(false),
       is_always_on_top_(false),
       use_native_frame_(false),
       use_argb_visual_(false),
       drag_drop_client_(NULL),
       current_cursor_(ui::kCursorNull),
       native_widget_delegate_(native_widget_delegate),
       desktop_native_widget_aura_(desktop_native_widget_aura),
       content_window_(NULL),
       window_parent_(NULL),
-      window_shape_(NULL),
-      custom_window_shape_(false),
+      custom_window_shape_(NULL),
       urgency_hint_set_(false) {
 }
 
 DesktopWindowTreeHostX11::~DesktopWindowTreeHostX11() {
   window()->ClearProperty(kHostForRootWindow);
   aura::client::SetWindowMoveClient(window(), NULL);
   desktop_native_widget_aura_->OnDesktopWindowTreeHostDestroyed(this);
-  if (window_shape_)
-    XDestroyRegion(window_shape_);
+  if (custom_window_shape_)
+    XDestroyRegion(custom_window_shape_);
   DestroyDispatcher();
 }
 
 // static
 aura::Window* DesktopWindowTreeHostX11::GetContentWindowForXID(XID xid) {
   aura::WindowTreeHost* host =
       aura::WindowTreeHost::GetForAcceleratedWidget(xid);
   return host ? host->window()->GetProperty(kViewsWindowForRootWindow) : NULL;
 }
 
@@ skipping 11 matching lines @@
                  open_windows().end(),
                  windows.begin(),
                  GetContentWindowForXID);
   return windows;
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetX11RootWindowBounds() const {
   return bounds_;
 }
 
-gfx::Rect DesktopWindowTreeHostX11::GetX11RootWindowOuterBounds() const {
-  gfx::Rect outer_bounds(bounds_);
-  outer_bounds.Inset(-native_window_frame_borders_);
-  return outer_bounds;
-}
-
-::Region DesktopWindowTreeHostX11::GetWindowShape() const {
-  return window_shape_;
-}
-
 void DesktopWindowTreeHostX11::HandleNativeWidgetActivationChanged(
     bool active) {
   if (active) {
     FlashFrame(false);
     OnHostActivated();
     open_windows().remove(xwindow_);
     open_windows().insert(open_windows().begin(), xwindow_);
   }
 
   desktop_native_widget_aura_->HandleActivationChanged(active);
@@ skipping 131 matching lines @@
 
   desktop_native_widget_aura_->OnHostClosed();
 }
 
 aura::WindowTreeHost* DesktopWindowTreeHostX11::AsWindowTreeHost() {
   return this;
 }
 
 void DesktopWindowTreeHostX11::ShowWindowWithState(
     ui::WindowShowState show_state) {
-  if (!window_mapped_) {
+  if (!window_mapped_)
     MapWindow(show_state);
-    ResetWindowRegion();
-  }
 
   if (show_state == ui::SHOW_STATE_NORMAL ||
       show_state == ui::SHOW_STATE_MAXIMIZED) {
     // Note: XFCE ignores a maximize hint given before mapping the window.
     if (show_state == ui::SHOW_STATE_MAXIMIZED)
       Maximize();
     Activate();
   }
 
   native_widget_delegate_->AsWidget()->SetInitialFocus(show_state);
@@ skipping 110 matching lines @@
   if (!XGetGeometry(xdisplay_, x_root_window_, &root, &x, &y,
                     &width, &height, &border_width, &depth)) {
     NOTIMPLEMENTED();
     return gfx::Rect(0, 0, 10, 10);
   }
 
   return gfx::Rect(x, y, width, height);
 }
 
 void DesktopWindowTreeHostX11::SetShape(gfx::NativeRegion native_region) {
-  if (window_shape_)
-    XDestroyRegion(window_shape_);
-  custom_window_shape_ = true;
-  window_shape_ = gfx::CreateRegionFromSkRegion(*native_region);
+  if (custom_window_shape_)
+    XDestroyRegion(custom_window_shape_);
+  custom_window_shape_ = gfx::CreateRegionFromSkRegion(*native_region);
   ResetWindowRegion();
   delete native_region;
 }
 
 void DesktopWindowTreeHostX11::Activate() {
   if (!window_mapped_)
     return;
 
   X11DesktopHandler::get()->ActivateWindow(xwindow_);
 }
@@ skipping 625 matching lines @@
   // 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) {
     SetWindowIcons(gfx::ImageSkia(), *window_icon);
   }
   CreateCompositor(GetAcceleratedWidget());
 }
 
-void DesktopWindowTreeHostX11::OnWMStateUpdated() {
-  std::vector< ::Atom> atom_list;
-  if (!ui::GetAtomArrayProperty(xwindow_, "_NET_WM_STATE", &atom_list))
-    return;
-
-  window_properties_.clear();
-  std::copy(atom_list.begin(), atom_list.end(),
-            inserter(window_properties_, window_properties_.begin()));
-
-  if (!restored_bounds_.IsEmpty() && !IsMaximized()) {
-    // If we have restored bounds, but WM_STATE no longer claims to be
-    // maximized, we should clear our restored bounds.
-    restored_bounds_ = gfx::Rect();
-  } else if (IsMaximized() && restored_bounds_.IsEmpty()) {
-    // The request that we become maximized originated from a different process.
-    // |bounds_| already contains our maximized bounds. Do a best effort attempt
-    // to get restored bounds by setting it to our previously set bounds (and if
-    // we get this wrong, we aren't any worse off since we'd otherwise be
-    // returning our maximized bounds).
-    restored_bounds_ = previous_bounds_;
-  }
-
-  is_fullscreen_ = HasWMSpecProperty("_NET_WM_STATE_FULLSCREEN");
-  is_always_on_top_ = HasWMSpecProperty("_NET_WM_STATE_ABOVE");
-
-  // Now that we have different window properties, we may need to relayout the
-  // window. (The windows code doesn't need this because their window change is
-  // synchronous.)
-  //
-  // TODO(erg): While this does work, there's a quick flash showing the
-  // tabstrip/toolbar/etc. when going into fullscreen mode before hiding those
-  // parts of the UI because we receive the sizing event from the window
-  // manager before we receive the event that changes the fullscreen state.
-  // Unsure what to do about that.
-  Widget* widget = native_widget_delegate_->AsWidget();
-  NonClientView* non_client_view = widget->non_client_view();
-  // non_client_view may be NULL, especially during creation.
-  if (non_client_view) {
-    non_client_view->client_view()->InvalidateLayout();
-    non_client_view->InvalidateLayout();
-  }
-  widget->GetRootView()->Layout();
-  // Refresh the window's border, which may need to be updated if we have
-  // changed the window's maximization state.
-  ResetWindowRegion();
-}
-
-void DesktopWindowTreeHostX11::OnFrameExtentsUpdated() {
-  std::vector<int> insets;
-  if (ui::GetIntArrayProperty(xwindow_, "_NET_FRAME_EXTENTS", &insets) &&
-      insets.size() == 4) {
-    // |insets| are returned in the order: [left, right, top, bottom].
-    native_window_frame_borders_ = gfx::Insets(
-        insets[2],
-        insets[0],
-        insets[3],
-        insets[1]);
-  } else {
-    native_window_frame_borders_ = gfx::Insets();
-  }
-}
-
 void DesktopWindowTreeHostX11::SetWMSpecState(bool enabled,
                                                 ::Atom state1,
                                                 ::Atom state2) {
   XEvent xclient;
   memset(&xclient, 0, sizeof(xclient));
   xclient.type = ClientMessage;
   xclient.xclient.window = xwindow_;
   xclient.xclient.message_type = atom_cache_.GetAtom("_NET_WM_STATE");
   xclient.xclient.format = 32;
   xclient.xclient.data.l[0] =
@@ skipping 73 matching lines @@
     g_current_capture->SendEventToProcessor(event);
   } else {
     SendEventToProcessor(event);
   }
 }
 
 void DesktopWindowTreeHostX11::ResetWindowRegion() {
   // If a custom window shape was supplied then apply it.
   if (custom_window_shape_) {
     XShapeCombineRegion(
-        xdisplay_, xwindow_, ShapeBounding, 0, 0, window_shape_, false);
+        xdisplay_, xwindow_, ShapeBounding, 0, 0, custom_window_shape_, false);
     return;
   }
 
-  if (window_shape_)
-    XDestroyRegion(window_shape_);
-  window_shape_ = NULL;
-
   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.
       widget->non_client_view()->GetWindowMask(bounds_.size(), &window_mask);
       if (window_mask.countPoints() > 0) {
-        window_shape_ = gfx::CreateRegionFromSkPath(window_mask);
+        Region region = gfx::CreateRegionFromSkPath(window_mask);
         XShapeCombineRegion(xdisplay_, xwindow_, ShapeBounding,
-                            0, 0, window_shape_, false);
+                            0, 0, region, false);
+        XDestroyRegion(region);
         return;
       }
     }
   }
 
   // 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
@@ skipping 362 matching lines @@
         } else {
           break;
         }
       }
 
       ui::MouseEvent mouseev(xev);
       DispatchMouseEvent(&mouseev);
       break;
     }
     case PropertyNotify: {
-      ::Atom changed_atom = xev->xproperty.atom;
-      if (changed_atom == atom_cache_.GetAtom("_NET_WM_STATE"))
-        OnWMStateUpdated();
-      else if (changed_atom == atom_cache_.GetAtom("_NET_FRAME_EXTENTS"))
-        OnFrameExtentsUpdated();
+      // Get our new window property state if the WM has told us its changed.
+      ::Atom state = atom_cache_.GetAtom("_NET_WM_STATE");
+
+      std::vector< ::Atom> atom_list;
+      if (xev->xproperty.atom == state &&
+          ui::GetAtomArrayProperty(xwindow_, "_NET_WM_STATE", &atom_list)) {
+        window_properties_.clear();
+        std::copy(atom_list.begin(), atom_list.end(),
+                  inserter(window_properties_, window_properties_.begin()));
+
+        if (!restored_bounds_.IsEmpty() && !IsMaximized()) {
+          // If we have restored bounds, but WM_STATE no longer claims to be
+          // maximized, we should clear our restored bounds.
+          restored_bounds_ = gfx::Rect();
+        } else if (IsMaximized() && restored_bounds_.IsEmpty()) {
+          // The request that we become maximized originated from a different
+          // process. |bounds_| already contains our maximized bounds. Do a
+          // best effort attempt to get restored bounds by setting it to our
+          // previously set bounds (and if we get this wrong, we aren't any
+          // worse off since we'd otherwise be returning our maximized bounds).
+          restored_bounds_ = previous_bounds_;
+        }
+
+        is_fullscreen_ = HasWMSpecProperty("_NET_WM_STATE_FULLSCREEN");
+        is_always_on_top_ = HasWMSpecProperty("_NET_WM_STATE_ABOVE");
+
+        // Now that we have different window properties, we may need to
+        // relayout the window. (The windows code doesn't need this because
+        // their window change is synchronous.)
+        //
+        // TODO(erg): While this does work, there's a quick flash showing the
+        // tabstrip/toolbar/etc. when going into fullscreen mode before hiding
+        // those parts of the UI because we receive the sizing event from the
+        // window manager before we receive the event that changes the
+        // fullscreen state. Unsure what to do about that.
+        Widget* widget = native_widget_delegate_->AsWidget();
+        NonClientView* non_client_view = widget->non_client_view();
+        // non_client_view may be NULL, especially during creation.
+        if (non_client_view) {
+          non_client_view->client_view()->InvalidateLayout();
+          non_client_view->InvalidateLayout();
+        }
+        widget->GetRootView()->Layout();
+        // Refresh the window's border, which may need to be updated if we have
+        // changed the window's maximization state.
+        ResetWindowRegion();
+      }
       break;
     }
     case SelectionNotify: {
       drag_drop_client_->OnSelectionNotify(xev->xselection);
       break;
     }
   }
   return ui::POST_DISPATCH_STOP_PROPAGATION;
 }
 
@@ skipping 14 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme(window);
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views