Attempt at once-and-for-all fix for bug #2993 (Windows)

views/widget/widget_win.cc

 // Copyright (c) 2006-2008 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 "views/widget/widget_win.h"
 
 #include "app/gfx/canvas.h"
 #include "app/gfx/path.h"
 #include "app/win_util.h"
 #include "base/gfx/native_theme.h"
@@ skipping 126 matching lines @@
     : close_widget_factory_(this),
       active_mouse_tracking_flags_(0),
       has_capture_(false),
       window_style_(0),
       window_ex_style_(kWindowDefaultExStyle),
       use_layered_buffer_(true),
       layered_alpha_(255),
       delete_on_destroy_(true),
       can_update_layered_window_(true),
       last_mouse_event_was_move_(false),
+      mouse_buttons_are_swapped_(0 != GetSystemMetrics(SM_SWAPBUTTON)),
+      buttons_pressed_(0),
+      released_buttons_out_of_order_(0),
       is_mouse_down_(false),
       is_window_(false),
       class_style_(CS_DBLCLKS),
       hwnd_(NULL) {
+  left_button_code_ = mouse_buttons_are_swapped_ ? VK_RBUTTON : VK_LBUTTON;
+  right_button_code_ = mouse_buttons_are_swapped_ ? VK_LBUTTON : VK_RBUTTON;
 }
 
 WidgetWin::~WidgetWin() {
   MessageLoopForUI::current()->RemoveObserver(this);
 }
 
 void WidgetWin::Init(HWND parent, const gfx::Rect& bounds) {
   if (window_style_ == 0)
     window_style_ = parent ? kWindowDefaultChildStyle : kWindowDefaultStyle;
 
@@ skipping 448 matching lines @@
   KeyEvent event(Event::ET_KEY_PRESSED, c, rep_cnt, flags);
   SetMsgHandled(root_view_->ProcessKeyEvent(event));
 }
 
 void WidgetWin::OnKeyUp(TCHAR c, UINT rep_cnt, UINT flags) {
   KeyEvent event(Event::ET_KEY_RELEASED, c, rep_cnt, flags);
   SetMsgHandled(root_view_->ProcessKeyEvent(event));
 }
 
 void WidgetWin::OnLButtonDown(UINT flags, const CPoint& point) {
-  ProcessMousePressed(point, flags | MK_LBUTTON, false, false);
+  // Clear out-of-order release flag in case the "button released" event
+  // was truly completely swallowed.
+  released_buttons_out_of_order_ &= ~left_button_code_;
+  if (ProcessMousePressed(point, flags | MK_LBUTTON, false, false))
+    buttons_pressed_ |= left_button_code_;
 }
 
 void WidgetWin::OnLButtonUp(UINT flags, const CPoint& point) {
-  ProcessMouseReleased(point, flags | MK_LBUTTON);
+  // If we already generated the event for this button out of order,
+  // avoid doing it twice.
+  if (0 == (released_buttons_out_of_order_ & left_button_code_)) {
+    ProcessMouseReleased(point, flags | MK_LBUTTON);
+  }
+  released_buttons_out_of_order_ &= ~left_button_code_;
+  buttons_pressed_ &= ~left_button_code_;
 }
 
 void WidgetWin::OnLButtonDblClk(UINT flags, const CPoint& point) {
   ProcessMousePressed(point, flags | MK_LBUTTON, true, false);
 }
 
 void WidgetWin::OnMButtonDown(UINT flags, const CPoint& point) {
-  ProcessMousePressed(point, flags | MK_MBUTTON, false, false);
+  // Clear out-of-order release flag in case the "button released" event
+  // was truly completely swallowed.
+  released_buttons_out_of_order_ &= ~VK_MBUTTON;
+  if (ProcessMousePressed(point, flags | MK_MBUTTON, false, false))
+    buttons_pressed_ |= VK_MBUTTON;
 }
 
 void WidgetWin::OnMButtonUp(UINT flags, const CPoint& point) {
-  ProcessMouseReleased(point, flags | MK_MBUTTON);
+  // If we already generated the event for this button out of order,
+  // avoid doing it twice.
+  if (0 == (released_buttons_out_of_order_ & VK_MBUTTON)) {
+    ProcessMouseReleased(point, flags | MK_MBUTTON);
+  }
+  released_buttons_out_of_order_ &= ~VK_MBUTTON;
+  buttons_pressed_ &= ~VK_MBUTTON;
 }
 
 void WidgetWin::OnMButtonDblClk(UINT flags, const CPoint& point) {
   ProcessMousePressed(point, flags | MK_MBUTTON, true, false);
 }
 
 LRESULT WidgetWin::OnMouseActivate(HWND window, UINT hittest_code,
                                    UINT message) {
   SetMsgHandled(FALSE);
   return MA_ACTIVATE;
@@ skipping 96 matching lines @@
   }
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void WidgetWin::OnPaint(HDC dc) {
   root_view_->OnPaint(GetNativeView());
 }
 
 void WidgetWin::OnRButtonDown(UINT flags, const CPoint& point) {
-  ProcessMousePressed(point, flags | MK_RBUTTON, false, false);
+  // Clear out-of-order release flag in case the "button released" event
+  // was truly completely swallowed.
+  released_buttons_out_of_order_ &= ~right_button_code_;
+  if (ProcessMousePressed(point, flags | MK_RBUTTON, false, false))
+    buttons_pressed_ |= right_button_code_;
 }
 
 void WidgetWin::OnRButtonUp(UINT flags, const CPoint& point) {
-  ProcessMouseReleased(point, flags | MK_RBUTTON);
+  // If we already generated the event for this button out of order,
+  // avoid doing it twice.
+  if (0 == (released_buttons_out_of_order_ & right_button_code_)) {
+    ProcessMouseReleased(point, flags | MK_RBUTTON);
+  }
+  released_buttons_out_of_order_ &= ~right_button_code_;
+  buttons_pressed_ &= ~right_button_code_;
 }
 
 void WidgetWin::OnRButtonDblClk(UINT flags, const CPoint& point) {
   ProcessMousePressed(point, flags | MK_RBUTTON, true, false);
 }
 
 void WidgetWin::OnSize(UINT param, const CSize& size) {
   ChangeSize(param, size);
 }
 
@@ skipping 45 matching lines @@
   if (non_client)
     View::ConvertPointToView(NULL, root_view_.get(), &converted_point);
   MouseEvent mouse_pressed(Event::ET_MOUSE_PRESSED,
                            converted_point.x(),
                            converted_point.y(),
                            (dbl_click ? MouseEvent::EF_IS_DOUBLE_CLICK : 0) |
                            (non_client ? MouseEvent::EF_IS_NON_CLIENT : 0) |
                            Event::ConvertWindowsFlags(flags));
   if (root_view_->OnMousePressed(mouse_pressed)) {
     is_mouse_down_ = true;
+    gfx::Point screen_loc(point);
+    View::ConvertPointToScreen(root_view_.get(), &screen_loc);
+    last_mouse_move_x_ = screen_loc.x();
+    last_mouse_move_y_ = screen_loc.y();
+    last_mouse_event_was_move_ = false;
     if (!has_capture_) {
       SetCapture();
       has_capture_ = true;
     }
     return true;
   }
   return false;
 }
 
 void WidgetWin::ProcessMouseDragged(const CPoint& point, UINT flags) {
@@ skipping 16 matching lines @@
   if (has_capture_ && ReleaseCaptureOnMouseReleased()) {
     has_capture_ = false;
     ReleaseCapture();
   }
   is_mouse_down_ = false;
   root_view_->OnMouseReleased(mouse_up, false);
 }
 
 void WidgetWin::ProcessMouseMoved(const CPoint &point, UINT flags,
                                   bool is_nonclient) {
+  // Under heavy load it may happen that a mouse release event gets
+  // "swallowed" or postponed. Explicitely check mouse button state here
+  // to make sure this hasn't happened.
+  CheckOutOfOrderMouseButtonRelease(left_button_code_);
+  CheckOutOfOrderMouseButtonRelease(VK_MBUTTON);
+  CheckOutOfOrderMouseButtonRelease(right_button_code_);
   // Windows only fires WM_MOUSELEAVE events if the application begins
   // "tracking" mouse events for a given HWND during WM_MOUSEMOVE events.
   // We need to call |TrackMouseEvents| to listen for WM_MOUSELEAVE.
   if (!has_capture_)
     TrackMouseEvents(is_nonclient ? TME_NONCLIENT | TME_LEAVE : TME_LEAVE);
+
+  gfx::Point screen_loc(point);
+  View::ConvertPointToScreen(root_view_.get(), &screen_loc);
   if (has_capture_ && is_mouse_down_) {
     ProcessMouseDragged(point, flags);
   } else {
-    gfx::Point screen_loc(point);
-    View::ConvertPointToScreen(root_view_.get(), &screen_loc);
     if (last_mouse_event_was_move_ && last_mouse_move_x_ == screen_loc.x() &&
         last_mouse_move_y_ == screen_loc.y()) {
       // Don't generate a mouse event for the same location as the last.
       return;
     }
-    last_mouse_move_x_ = screen_loc.x();
-    last_mouse_move_y_ = screen_loc.y();
     last_mouse_event_was_move_ = true;
     MouseEvent mouse_move(Event::ET_MOUSE_MOVED,
                           point.x,
                           point.y,
                           Event::ConvertWindowsFlags(flags));
     root_view_->OnMouseMoved(mouse_move);
   }
+  last_mouse_move_x_ = screen_loc.x();
+  last_mouse_move_y_ = screen_loc.y();
 }
 
 void WidgetWin::ProcessMouseExited() {
   last_mouse_event_was_move_ = false;
   root_view_->ProcessOnMouseExited();
   // Reset our tracking flag so that future mouse movement over this WidgetWin
   // results in a new tracking session.
   active_mouse_tracking_flags_ = 0;
 }
 
+void WidgetWin::CheckOutOfOrderMouseButtonRelease(int code) {
+  SHORT key_state = ::GetAsyncKeyState(code);
+  if ((0 == (key_state & 0x8000)) &&
+      (0 != (buttons_pressed_ & code))) {
+    // left button was released in the meantime
+    // generate an out-of-order event for this, at the last recorded position
+    CPoint pt(last_mouse_move_x_, last_mouse_move_y_);
+    ProcessMouseReleased(pt, code);
+    released_buttons_out_of_order_ |= code;
+    buttons_pressed_ &= ~code;
+  }
+}
+
 void WidgetWin::ChangeSize(UINT size_param, const CSize& size) {
   CRect rect;
   if (use_layered_buffer_) {
     GetWindowRect(&rect);
     SizeContents(rect);
   } else {
     GetClientRect(&rect);
   }
 
   // Resizing changes the size of the view hierarchy and thus forces a
@@ skipping 180 matching lines @@
   }
   if (WA_INACTIVE == activation_state) {
     widget->focus_manager_->StoreFocusedView();
   } else {
     // We must restore the focus after the message has been DefProc'ed as it
     // does set the focus to the last focused HWND.
     widget->focus_manager_->RestoreFocusedView();
   }
 }
 }  // namespace views