Fix unwanted mouse move on pointer unlock. (GTK)

content/browser/renderer_host/render_widget_host_view_gtk.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 "content/browser/renderer_host/render_widget_host_view_gtk.h"
 
 // If this gets included after the gtk headers, then a bunch of compiler
 // errors happen because of a "#define Status int" in Xlib.h, which interacts
 // badly with net::URLRequestStatus::Status.
 #include "content/common/view_messages.h"
@@ skipping 83 matching lines @@
     GdkPixmap* mask = gdk_bitmap_create_from_data(
         NULL, reinterpret_cast<const gchar*>(moz_spinning_mask_bits), 32, 32);
     moz_spinning_cursor =
         gdk_cursor_new_from_pixmap(source, mask, &fg, &bg, 2, 2);
     g_object_unref(source);
     g_object_unref(mask);
   }
   return moz_spinning_cursor;
 }
 
-bool MovedToCenter(const WebKit::WebMouseEvent& mouse_event,
+bool MovedToPoint(const WebKit::WebMouseEvent& mouse_event,
                    const gfx::Point& center) {
   return mouse_event.globalX == center.x() &&
          mouse_event.globalY == center.y();
 }
 
 }  // namespace
 
 // This class is a simple convenience wrapper for Gtk functions. It has only
 // static methods.
 class RenderWidgetHostViewGtkWidget {
@@ skipping 269 matching lines @@
     }
 
     host_view->ModifyEventForEdgeDragging(widget, event);
 
     WebKit::WebMouseEvent mouse_event =
         WebInputEventFactory::mouseEvent(event);
 
     if (host_view->mouse_locked_) {
       gfx::Point center = host_view->GetWidgetCenter();
 
-      bool moved_to_center = MovedToCenter(mouse_event, center);
+      bool moved_to_center = MovedToPoint(mouse_event, center);
       if (moved_to_center)
         host_view->mouse_has_been_warped_to_new_center_ = true;
 
       host_view->ModifyEventMovementAndCoords(&mouse_event);
 
       if (!moved_to_center &&
           (mouse_event.movementX || mouse_event.movementY)) {
         GdkDisplay* display = gtk_widget_get_display(widget);
         GdkScreen* screen = gtk_widget_get_screen(widget);
         gdk_display_warp_pointer(display, screen, center.x(), center.y());
         if (host_view->mouse_has_been_warped_to_new_center_)
           RenderWidgetHostImpl::From(
               host_view->GetRenderWidgetHost())->ForwardMouseEvent(mouse_event);
       }
     } else {  // Mouse is not locked.
       host_view->ModifyEventMovementAndCoords(&mouse_event);
-      RenderWidgetHostImpl::From(
-          host_view->GetRenderWidgetHost())->ForwardMouseEvent(mouse_event);
+      // Do not send mouse events while the mouse cursor is being warped back
+      // to the unlocked location.
+      if (!host_view->mouse_is_being_warped_to_unlocked_position_) {
+        RenderWidgetHostImpl::From(
+            host_view->GetRenderWidgetHost())->ForwardMouseEvent(mouse_event);
+      }
     }
     return FALSE;
   }
 
   static gboolean OnCrossingEvent(GtkWidget* widget,
                                   GdkEventCrossing* event,
                                   RenderWidgetHostViewGtk* host_view) {
     TRACE_EVENT0("browser",
                  "RenderWidgetHostViewGtkWidget::OnCrossingEvent");
     const int any_button_mask =
@@ skipping 125 matching lines @@
     : host_(RenderWidgetHostImpl::From(widget_host)),
       about_to_validate_and_paint_(false),
       is_hidden_(false),
       is_loading_(false),
       parent_(NULL),
       is_popup_first_mouse_release_(true),
       was_imcontext_focused_before_grab_(false),
       do_x_grab_(false),
       is_fullscreen_(false),
       made_active_(false),
+      mouse_is_being_warped_to_unlocked_position_(false),
       destroy_handler_id_(0),
       dragged_at_horizontal_edge_(0),
       dragged_at_vertical_edge_(0),
       compositing_surface_(gfx::kNullPluginWindow),
       last_mouse_down_(NULL) {
   host_->SetView(this);
 }
 
 RenderWidgetHostViewGtk::~RenderWidgetHostViewGtk() {
   UnlockMouse();
@@ skipping 763 matching lines @@
 
   mouse_locked_ = false;
 
   GtkWidget* widget = view_.get();
   GdkDisplay* display = gtk_widget_get_display(widget);
   GdkScreen* screen = gtk_widget_get_screen(widget);
   gdk_display_pointer_ungrab(display, GDK_CURRENT_TIME);
   gdk_display_warp_pointer(display, screen,
                            unlocked_global_mouse_position_.x(),
                            unlocked_global_mouse_position_.y());
+  mouse_is_being_warped_to_unlocked_position_ = true;
 
   if (host_)
     host_->LostMouseLock();
 }
 
 void RenderWidgetHostViewGtk::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& event) {
   if (!host_)
     return;
 
@@ skipping 73 matching lines @@
     WebKit::WebMouseEvent* event) {
   // Movement is computed by taking the difference of the new cursor position
   // and the previous. Under mouse lock the cursor will be warped back to the
   // center so that we are not limited by clipping boundaries.
   // We do not measure movement as the delta from cursor to center because
   // we may receive more mouse movement events before our warp has taken
   // effect.
   event->movementX = event->globalX - global_mouse_position_.x();
   event->movementY = event->globalY - global_mouse_position_.y();
 
+  // While the cursor is being warped back to the unlocked position, suppress
+  // the movement member data.
+  if (mouse_is_being_warped_to_unlocked_position_) {
+    event->movementX = 0;
+    event->movementY = 0;
+    if (MovedToPoint(*event, unlocked_global_mouse_position_))
+      mouse_is_being_warped_to_unlocked_position_ = false;
+  }
+
   global_mouse_position_.SetPoint(event->globalX, event->globalY);
 
   // Under mouse lock, coordinates of mouse are locked to what they were when
   // mouse lock was entered.
   if (mouse_locked_) {
     event->x = unlocked_mouse_position_.x();
     event->y = unlocked_mouse_position_.y();
     event->windowX = unlocked_mouse_position_.x();
     event->windowY = unlocked_mouse_position_.y();
     event->globalX = unlocked_global_mouse_position_.x();
@@ skipping 86 matching lines @@
             this));
   }
   BrowserAccessibilityGtk* root =
       browser_accessibility_manager_->GetRoot()->ToBrowserAccessibilityGtk();
 
   atk_object_set_role(root->GetAtkObject(), ATK_ROLE_HTML_CONTAINER);
   return root->GetAtkObject();
 }
 
 }  // namespace content