ash: ozone: apply transformation to events outside the root window

ui/ozone/platform/dri/dri_window.cc

 // Copyright 2014 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/ozone/platform/dri/dri_window.h"
 
 #include "base/bind.h"
 #include "ui/events/event.h"
 #include "ui/events/ozone/evdev/event_factory_evdev.h"
 #include "ui/events/ozone/events_ozone.h"
@@ skipping 56 matching lines @@
   sender_->Send(new OzoneGpuMsg_WindowBoundsChanged(widget_, bounds));
 
   if (window_manager_->cursor()->GetCursorWindow() == widget_)
     window_manager_->cursor()->ShowCursor();
 }
 
 gfx::Rect DriWindow::GetBounds() {
   return bounds_;
 }
 
-void DriWindow::SetCapture() {}
+void DriWindow::SetCapture() {
+  window_manager_->GrabEvents(widget_);
+}
 
-void DriWindow::ReleaseCapture() {}
+void DriWindow::ReleaseCapture() {
+  window_manager_->UngrabEvents(widget_);
+}
 
 void DriWindow::ToggleFullscreen() {}
 
 void DriWindow::Maximize() {}
 
 void DriWindow::Minimize() {}
 
 void DriWindow::Restore() {}
 
 void DriWindow::SetCursor(PlatformCursor cursor) {
   DriCursor* dri_cursor = window_manager_->cursor();
   dri_cursor->SetCursor(widget_, cursor);
   // ShowCursor results in a IPC call to GPU. So, we make sure the channel
   // is connected. OnChannelEstablished guarantees that ShowCursor is called
   // eventually.
   if (sender_->IsConnected() && dri_cursor->GetCursorWindow() == widget_)
     dri_cursor->ShowCursor();
 }
 
 void DriWindow::MoveCursorTo(const gfx::Point& location) {
   event_factory_->WarpCursorTo(widget_, location);
 }
 
 bool DriWindow::CanDispatchEvent(const PlatformEvent& ne) {
   DCHECK(ne);
   Event* event = static_cast<Event*>(ne);
-  if (event->IsMouseEvent() || event->IsScrollEvent())
+
+  // Bail out if there is a grab on mouse events.
+  gfx::AcceleratedWidget grabber = window_manager_->event_grabber();
+  if (grabber != gfx::kNullAcceleratedWidget)
+    return grabber == widget_;

[spang, 2014/11/11 19:00:24]

Let's talk about this more.

Touch events should not be grabbed, they neither use the mouse cursor nor
respect keyboard focus.

Mouse press, drag, release events should.

Key events probably should, since you typically cannot remove keyboard focus
from the capturing window anyway. We haven't really implemented keyboard focus
separately from what's under the cursor in this function, because ash doesn't
care about it.

Dunno about scroll events. Sadrul suggested they should not. It makes some sense
that scrolling always acts at the location under the cursor. However: What about
mouse wheel? It's a mouse event. Should it be consistent with scroll events, or
with mouse events?

Gesture events are N/A don't go through this code path.

[llandwerlin-old, 2014/11/12 15:47:24]

Acknowledged.

[sadrul, 2014/11/19 21:07:10]

I think we do grab for touch-events. Can you verify our behaviour on X11?
We should grab scroll events too. I am not sure what I meant with my earlier
comment. Perhaps I misread the code/comment and thought we were doing an
implicit grab when we receive a scroll event.

+
+  if (event->IsMouseEvent() || event->IsScrollEvent()) {
+    // Otherwise, just consider the position of the cursor.
     return window_manager_->cursor()->GetCursorWindow() == widget_;
+  }
 
   return true;
 }
 
 uint32_t DriWindow::DispatchEvent(const PlatformEvent& native_event) {
+  // Implement implicit mouse grab on button press
+  Event* event = static_cast<Event*>(native_event);
+  if (event->IsLocatedEvent()) {

[spang, 2014/11/11 19:00:24]

As above, touch events must not be affected by the cursor location.

[llandwerlin-old, 2014/11/12 15:47:24]

They shouldn't be, because they will be delivered to the window on which the
cursor is, so the conditional statement
(window_manager_->cursor()->GetCursorWindow() != widget_) will fail.

[spang, 2014/11/19 18:32:30]

That conditional is only for mouse events. Touch events are for touchscreen
devices and must be delivered to a window even if it is not under the cursor.

The multi-window case wasn't implemented until recently but if you rebase,
there's more code here to handle it.

Anyway, you will break touch unless you to one of two things.

(1) Rebase and update the new function RewriteTouchEvent to set root_location
properly.

(2) Change the conditional for this block to exclude touch events.

+    // We need to convert the cursor's position into coordinates
+    // relative to the window in case of an implicit grab.
+    if (window_manager_->cursor()->GetCursorWindow() != widget_) {

[spang, 2014/11/19 18:32:30]

I don't think you need this conditional as the calculation is still correct when
the cursor is over the window.

+      LocatedEvent* located_event = static_cast<LocatedEvent*>(event);
+      gfx::PointF location = located_event->root_location();
+      location.Offset(-bounds_.origin().x(), -bounds_.origin().y());
+      located_event->set_location(location);
+    }
+  }
   DispatchEventFromNativeUiEvent(
       native_event, base::Bind(&PlatformWindowDelegate::DispatchEvent,
                                base::Unretained(delegate_)));
   return POST_DISPATCH_STOP_PROPAGATION;
 }
 
 void DriWindow::OnChannelEstablished() {
   sender_->Send(new OzoneGpuMsg_CreateWindowDelegate(widget_));
   sender_->Send(new OzoneGpuMsg_WindowBoundsChanged(widget_, bounds_));
 
   DriCursor* dri_cursor = window_manager_->cursor();
   if (dri_cursor->GetCursorWindow() == widget_)
     dri_cursor->ShowCursor();
 }
 
 void DriWindow::OnChannelDestroyed() {
 }
 
 }  // namespace ui