Enable setting capture to a non-toplevel widget when the widget is activated on Linux

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 187 matching lines @@
   return window_shape_;
 }
 
 void DesktopWindowTreeHostX11::HandleNativeWidgetActivationChanged(
     bool active) {
   if (active) {
     FlashFrame(false);
     OnHostActivated();
     open_windows().remove(xwindow_);
     open_windows().insert(open_windows().begin(), xwindow_);
+  } else {
+    ReleaseCapture();
   }
 
   desktop_native_widget_aura_->HandleActivationChanged(active);
 
   native_widget_delegate_->AsWidget()->GetRootView()->SchedulePaint();
 }
 
 void DesktopWindowTreeHostX11::AddObserver(
     views::DesktopWindowTreeHostObserverX11* observer) {
   observer_list_.AddObserver(observer);
@@ skipping 88 matching lines @@
         FROM_HERE,
         base::Bind(&DesktopWindowTreeHostX11::CloseNow,
                    close_widget_factory_.GetWeakPtr()));
   }
 }
 
 void DesktopWindowTreeHostX11::CloseNow() {
   if (xwindow_ == None)
     return;
 
-  x11_capture_.reset();
+  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();
        ++it) {
     (*it)->CloseNow();
   }
@@ skipping 176 matching lines @@
   if (!window_mapped_)
     return;
 
   X11DesktopHandler::get()->ActivateWindow(xwindow_);
 }
 
 void DesktopWindowTreeHostX11::Deactivate() {
   if (!IsActive())
     return;
 
-  x11_capture_.reset();
+  ReleaseCapture();
   X11DesktopHandler::get()->DeactivateWindow(xwindow_);
 }
 
 bool DesktopWindowTreeHostX11::IsActive() const {
   return X11DesktopHandler::get()->IsActiveWindow(xwindow_);
 }
 
 void DesktopWindowTreeHostX11::Maximize() {
   // When we are in the process of requesting to maximize a window, we can
   // accurately keep track of our restored bounds instead of relying on the
   // heuristics that are in the PropertyNotify and ConfigureNotify handlers.
   restored_bounds_ = bounds_;
 
   SetWMSpecState(true,
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
   if (IsMinimized())
     ShowWindowWithState(ui::SHOW_STATE_NORMAL);
 }
 
 void DesktopWindowTreeHostX11::Minimize() {
-  x11_capture_.reset();
+  ReleaseCapture();
   XIconifyWindow(xdisplay_, xwindow_, 0);
 }
 
 void DesktopWindowTreeHostX11::Restore() {
   SetWMSpecState(false,
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
   if (IsMinimized())
     ShowWindowWithState(ui::SHOW_STATE_NORMAL);
 }
@@ skipping 268 matching lines @@
   }
 
   XSetWMNormalHints(xdisplay_, xwindow_, &hints);
 }
 
 void DesktopWindowTreeHostX11::OnNativeWidgetFocus() {
   native_widget_delegate_->AsWidget()->GetInputMethod()->OnFocus();
 }
 
 void DesktopWindowTreeHostX11::OnNativeWidgetBlur() {
-  if (xwindow_) {
-    x11_capture_.reset();

[sadrul, 2014/07/14 16:58:00]

Can you explain this change?

[pkotwicz, 2014/07/14 18:25:20]

This line in particular made it pointless to grab capture when a non-toplevel
widget got activated (because the toplevel widget would lose focus killing the
capture which was just set)

Note that the order of events is:
1) old window loses activation
2) new window gains activation
3) old window loses focus
4) new window gains focus

I think that the intent of the code is to release capture when we are
deactivated. I have modified HandleNativeWidgetActivationChanged() to do just
that

The reason that I changed x11_capture_.reset() to ReleaseCapture() in this CL is
that the test that I wrote would pass with or without this CL (due to the fact
that the effect of x11_capture_.reset() is asynchronous. Using ReleaseCapture()
makes the test actually useful.

+  if (xwindow_)
     native_widget_delegate_->AsWidget()->GetInputMethod()->OnBlur();
-  }
 }
 
 bool DesktopWindowTreeHostX11::IsAnimatingClosed() const {
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostX11, aura::WindowTreeHost implementation:
 
 ui::EventSource* DesktopWindowTreeHostX11::GetEventSource() {
@@ skipping 976 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