Disambiguate OnMouseCaptureLost from OnMouseReleased, etc.

views/controls/menu/menu_controller.cc

 // Copyright (c) 2011 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/controls/menu/menu_controller.h"
 
 #include "base/i18n/rtl.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
@@ skipping 359 matching lines @@
 void MenuController::Cancel(ExitType type) {
   if (!showing_) {
     // This occurs if we're in the process of notifying the delegate for a drop
     // and the delegate cancels us.
     return;
   }
 
   MenuItemView* selected = state_.item;
   exit_type_ = type;
 
-  SendMouseReleaseToActiveView();
+  SendMouseCaptureLostToActiveView();
 
   // Hide windows immediately.
   SetSelection(NULL, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
 
   if (!blocking_run_) {
     // If we didn't block the caller we need to notify the menu, which
     // triggers deleting us.
     DCHECK(selected);
     showing_ = false;
     selected->GetRootMenuItem()->DropMenuClosed(true);
@@ skipping 120 matching lines @@
     int selection_types = SELECTION_UPDATE_IMMEDIATELY;
     if (state_.item == pending_state_.item && state_.submenu_open)
       selection_types |= SELECTION_OPEN_SUBMENU;
     SetSelection(pending_state_.item, selection_types);
     gfx::Point loc(event.location());
     View::ConvertPointToScreen(source->GetScrollViewContainer(), &loc);
 
     // If we open a context menu just return now
     if (part.menu->GetDelegate()->ShowContextMenu(
             part.menu, part.menu->GetCommand(), loc, true)) {
-      SendMouseReleaseToActiveView(source, event, true);
+      SendMouseCaptureLostToActiveView();
       return;
     }
   }
 
   // We can use Ctrl+click or the middle mouse button to recursively open urls
   // for selected folder menu items. If it's only a left click, show the
   // contents of the folder.
   if (!part.is_scroll() && part.menu &&
       !(part.menu->HasSubmenu() &&
         (event.flags() == ui::EF_LEFT_BUTTON_DOWN))) {
     if (active_mouse_view_) {
-      SendMouseReleaseToActiveView(source, event, false);
+      SendMouseReleaseToActiveView(source, event);
       return;
     }
     if (part.menu->GetDelegate()->IsTriggerableEvent(event)) {
       Accept(part.menu, event.flags());
       return;
     }
   } else if (part.type == MenuPart::MENU_ITEM) {
     // User either clicked on empty space, or a menu that has children.
     SetSelection(part.menu ? part.menu : state_.item,
                  SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
   }
-  SendMouseReleaseToActiveView(source, event, true);
+  SendMouseCaptureLostToActiveView();
 }
 
 void MenuController::OnMouseMoved(SubmenuView* source,
                                   const MouseEvent& event) {
   if (showing_submenu_)
     return;
 
   MenuPart part = GetMenuPartByScreenCoordinate(source, event.x(), event.y());
 
   UpdateScrolling(part);
@@ skipping 1233 matching lines @@
     // is currently true for the cases we are embedding views, but if we embed
     // more complex hierarchies it'll need to change.
     View::ConvertPointToScreen(event_source->GetScrollViewContainer(),
                                &target_menu_loc);
     View::ConvertPointToView(NULL, target_menu, &target_menu_loc);
     target = target_menu->GetEventHandlerForPoint(target_menu_loc);
     if (target == target_menu || !target->IsEnabled())
       target = NULL;
   }
   if (target != active_mouse_view_) {
-    if (active_mouse_view_) {
-      // TODO(msw): Revise api and uses with OnMouseCaptureLost (like ui/views).
-      // Send a mouse release with cancel set to true.
-      active_mouse_view_->OnMouseReleased(event, true);
-      active_mouse_view_ = NULL;
-    }
+    SendMouseCaptureLostToActiveView();
     active_mouse_view_ = target;
     if (active_mouse_view_) {
       gfx::Point target_point(target_menu_loc);
       View::ConvertPointToView(target_menu, active_mouse_view_, &target_point);
       MouseEvent mouse_entered_event(ui::ET_MOUSE_ENTERED,
                                      target_point.x(), target_point.y(), 0);
       active_mouse_view_->OnMouseEntered(mouse_entered_event);
 
       MouseEvent mouse_pressed_event(ui::ET_MOUSE_PRESSED,
                                      target_point.x(), target_point.y(),
                                      event.flags());
       active_mouse_view_->OnMousePressed(mouse_pressed_event);
     }
   }
 
   if (active_mouse_view_) {
     gfx::Point target_point(target_menu_loc);
     View::ConvertPointToView(target_menu, active_mouse_view_, &target_point);
     MouseEvent mouse_dragged_event(ui::ET_MOUSE_DRAGGED,
                                    target_point.x(), target_point.y(),
                                    event.flags());
     active_mouse_view_->OnMouseDragged(mouse_dragged_event);
   }
 }
 
 void MenuController::SendMouseReleaseToActiveView(SubmenuView* event_source,
-                                                  const MouseEvent& event,
-                                                  bool cancel) {
+                                                  const MouseEvent& event) {
   if (!active_mouse_view_)
     return;
 
   gfx::Point target_loc(event.location());
   View::ConvertPointToScreen(event_source->GetScrollViewContainer(),
                              &target_loc);
   View::ConvertPointToView(NULL, active_mouse_view_, &target_loc);
   MouseEvent release_event(ui::ET_MOUSE_RELEASED, target_loc.x(),
                            target_loc.y(), event.flags());
-  // Reset the active_mouse_view_ before sending mouse released. That way if if
-  // calls back to use we aren't in a weird state.
+  // Reset the active_mouse_view_ before sending mouse released. That way if it
+  // calls back to us, we aren't in a weird state.
   View* active_view = active_mouse_view_;
   active_mouse_view_ = NULL;
-  active_view->OnMouseReleased(release_event, cancel);
+  active_view->OnMouseReleased(release_event);
 }
 
-void MenuController::SendMouseReleaseToActiveView() {
+void MenuController::SendMouseCaptureLostToActiveView() {
   if (!active_mouse_view_)
     return;
 
-  MouseEvent release_event(ui::ET_MOUSE_RELEASED, -1, -1, 0);
-  // Reset the active_mouse_view_ before sending mouse released. That way if if
-  // calls back to use we aren't in a weird state.
+  // Reset the active_mouse_view_ before sending mouse capture lost. That way if
+  // it calls back to us, we aren't in a weird state.
   View* active_view = active_mouse_view_;
   active_mouse_view_ = NULL;
-  active_view->OnMouseReleased(release_event, true);
+  active_view->OnMouseCaptureLost();
 }
 
 }  // namespace views