Adds some debugging in code in hopes of figuring out a crash in the

views/controls/menu/menu_controller.cc

 // Copyright (c) 2010 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 "app/l10n_util.h"
 #include "base/i18n/rtl.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 269 matching lines @@
   }
 
   // Reset current state.
   pending_state_ = State();
   state_ = State();
   UpdateInitialLocation(bounds, position);
 
   owner_ = parent;
 
   // Set the selection, which opens the initial menu.
-  SetSelection(root, true, true);
+  SetSelection(root, SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
 
   if (!blocking_run_) {
     // Start the timer to hide the menu. This is needed as we get no
     // notification when the drag has finished.
     StartCancelAllTimer();
     return NULL;
   } else if (button) {
     menu_button_ = button;
   }
 
   // Make sure Chrome doesn't attempt to shut down while the menu is showing.
   if (ViewsDelegate::views_delegate)
     ViewsDelegate::views_delegate->AddRef();
 
   // We need to turn on nestable tasks as in some situations (pressing alt-f for
   // one) the menus are run from a task. If we don't do this and are invoked
   // from a task none of the tasks we schedule are processed and the menu
   // appears totally broken.
   MessageLoopForUI* loop = MessageLoopForUI::current();
   bool did_allow_task_nesting = loop->NestableTasksAllowed();
   loop->SetNestableTasksAllowed(true);
   loop->Run(this);
   loop->SetNestableTasksAllowed(did_allow_task_nesting);
 
   if (ViewsDelegate::views_delegate)
     ViewsDelegate::views_delegate->ReleaseRef();
 
   // Close any open menus.
-  SetSelection(NULL, false, true);
+  SetSelection(NULL, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
 
   if (nested_menu) {
     DCHECK(!menu_stack_.empty());
     // We're running from within a menu, restore the previous state.
     // The menus are already showing, so we don't have to show them.
     state_ = menu_stack_.back();
     pending_state_ = menu_stack_.back();
     menu_stack_.pop_back();
   } else {
     showing_ = false;
@@ skipping 25 matching lines @@
   // If we stopped running because one of the menus was destroyed chances are
   // the button was also destroyed.
   if (exit_type_ != EXIT_DESTROYED && menu_button_) {
     menu_button_->SetState(CustomButton::BS_NORMAL);
     menu_button_->SchedulePaint();
   }
 
   return result;
 }
 
-void MenuController::SetSelection(MenuItemView* menu_item,
-                                  bool open_submenu,
-                                  bool update_immediately) {
-  size_t paths_differ_at = 0;
-  std::vector<MenuItemView*> current_path;
-  std::vector<MenuItemView*> new_path;
-  BuildPathsAndCalculateDiff(pending_state_.item, menu_item, &current_path,
-                             &new_path, &paths_differ_at);
-
-  size_t current_size = current_path.size();
-  size_t new_size = new_path.size();
-
-  if (pending_state_.item != menu_item && pending_state_.item) {
-    View* current_hot_view = GetFirstHotTrackedView(pending_state_.item);
-    if (current_hot_view)
-      current_hot_view->SetHotTracked(false);
-  }
-
-  // Notify the old path it isn't selected.
-  for (size_t i = paths_differ_at; i < current_size; ++i)
-    current_path[i]->SetSelected(false);
-
-  // Notify the new path it is selected.
-  for (size_t i = paths_differ_at; i < new_size; ++i)
-    new_path[i]->SetSelected(true);
-
-  if (menu_item && menu_item->GetDelegate())
-    menu_item->GetDelegate()->SelectionChanged(menu_item);
-
-  pending_state_.item = menu_item;
-  pending_state_.submenu_open = open_submenu;
-
-  // Stop timers.
-  StopShowTimer();
-  StopCancelAllTimer();
-
-  if (update_immediately)
-    CommitPendingSelection();
-  else
-    StartShowTimer();
-
-  // Notify an accessibility focus event on all menu items except for the root.
-  if (menu_item &&
-      (MenuDepth(menu_item) != 1 ||
-          menu_item->GetType() != MenuItemView::SUBMENU))
-    menu_item->NotifyAccessibilityEvent(AccessibilityTypes::EVENT_FOCUS);
-}
-
 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();
 
   // Hide windows immediately.
-  SetSelection(NULL, false, true);
+  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);
     // WARNING: the call to MenuClosed deletes us.
     return;
   }
@@ skipping 21 matching lines @@
 #if defined(OS_WIN)
     RepostEvent(source, event);
     // NOTE: not reposting on linux seems fine.
 #endif
 
     // And close.
     Cancel(EXIT_ALL);
     return;
   }
 
-  bool open_submenu = false;
+  // On a press we immediately commit the selection, that way a submenu
+  // pops up immediately rather than after a delay.
+  int selection_types = SELECTION_UPDATE_IMMEDIATELY;
   if (!part.menu) {
     part.menu = part.parent;
-    open_submenu = true;
+    selection_types |= SELECTION_OPEN_SUBMENU;
   } else {
     if (part.menu->GetDelegate()->CanDrag(part.menu)) {
       possible_drag_ = true;
       press_pt_ = event.location();
     }
     if (part.menu->HasSubmenu())
-      open_submenu = true;
+      selection_types |= SELECTION_OPEN_SUBMENU;
   }
-  // On a press we immediately commit the selection, that way a submenu
-  // pops up immediately rather than after a delay.
-  SetSelection(part.menu, open_submenu, true);
+  SetSelection(part.menu, selection_types);
 }
 
 void MenuController::OnMouseDragged(SubmenuView* source,
                                     const MouseEvent& event) {
   MenuPart part = GetMenuPartByScreenCoordinate(source, event.x(), event.y());
   UpdateScrolling(part);
 
   if (!blocking_run_)
     return;
 
@@ skipping 32 matching lines @@
       }  // else case, someone canceled us, don't do anything
     }
     return;
   }
   MenuItemView* mouse_menu = NULL;
   if (part.type == MenuPart::MENU_ITEM) {
     if (!part.menu)
       part.menu = source->GetMenuItem();
     else
       mouse_menu = part.menu;
-    SetSelection(part.menu ? part.menu : state_.item, true, false);
+    SetSelection(part.menu ? part.menu : state_.item, SELECTION_OPEN_SUBMENU);
   } else if (part.type == MenuPart::NONE) {
     ShowSiblingMenu(source, event);
   }
   UpdateActiveMouseView(source, event, mouse_menu);
 }
 
 void MenuController::OnMouseReleased(SubmenuView* source,
                                      const MouseEvent& event) {
   if (!blocking_run_)
     return;
 
   DCHECK(state_.item);
   possible_drag_ = false;
   DCHECK(blocking_run_);
   MenuPart part = GetMenuPartByScreenCoordinate(source, event.x(), event.y());
   if (event.IsRightMouseButton() && (part.type == MenuPart::MENU_ITEM &&
                                      part.menu)) {
     // Set the selection immediately, making sure the submenu is only open
     // if it already was.
-    bool open_submenu = (state_.item == pending_state_.item &&
-                         state_.submenu_open);
-    SetSelection(pending_state_.item, open_submenu, true);
+    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);
       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.GetFlags() == MouseEvent::EF_LEFT_BUTTON_DOWN))) {
     if (active_mouse_view_) {
       SendMouseReleaseToActiveView(source, event, false);
       return;
     }
     if (part.menu->GetDelegate()->IsTriggerableEvent(event)) {
       Accept(part.menu, event.GetFlags());
       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, true, true);
+    SetSelection(part.menu ? part.menu : state_.item,
+                 SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
   }
   SendMouseReleaseToActiveView(source, event, true);
 }
 
 void MenuController::OnMouseMoved(SubmenuView* source,
                                   const MouseEvent& event) {
   if (showing_submenu_)
     return;
 
   MenuPart part = GetMenuPartByScreenCoordinate(source, event.x(), event.y());
 
   UpdateScrolling(part);
 
   if (!blocking_run_)
     return;
 
   if (part.type == MenuPart::NONE && ShowSiblingMenu(source, event))
     return;
 
   if (part.type == MenuPart::MENU_ITEM && part.menu) {
-    SetSelection(part.menu, true, false);
+    SetSelection(part.menu, SELECTION_OPEN_SUBMENU);
   } else if (!part.is_scroll() && pending_state_.item &&
              (!pending_state_.item->HasSubmenu() ||
               !pending_state_.item->GetSubmenu()->IsShowing())) {
     // On exit if the user hasn't selected an item with a submenu, move the
     // selection back to the parent menu item.
-    SetSelection(pending_state_.item->GetParentMenuItem(), true, false);
+    SetSelection(pending_state_.item->GetParentMenuItem(),
+                 SELECTION_OPEN_SUBMENU);
   }
 }
 
 void MenuController::OnMouseEntered(SubmenuView* source,
                                     const MouseEvent& event) {
   // MouseEntered is always followed by a mouse moved, so don't need to
   // do anything here.
 }
 
 bool MenuController::GetDropFormats(
@@ skipping 56 matching lines @@
       }
       query_menu_item = menu_item;
     } else {
       query_menu_item = menu_item->GetParentMenuItem();
       drop_position = MenuDelegate::DROP_ON;
     }
     drop_operation = menu_item->GetDelegate()->GetDropOperation(
         query_menu_item, event, &drop_position);
 
     // If the menu has a submenu, schedule the submenu to open.
-    SetSelection(menu_item, menu_item->HasSubmenu(), false);
+    SetSelection(menu_item, menu_item->HasSubmenu() ? SELECTION_OPEN_SUBMENU :
+                 SELECTION_DEFAULT);
 
     if (drop_position == MenuDelegate::DROP_NONE ||
         drop_operation == DragDropTypes::DRAG_NONE)
       menu_item = NULL;
   } else {
-    SetSelection(source->GetMenuItem(), true, false);
+    SetSelection(source->GetMenuItem(), SELECTION_OPEN_SUBMENU);
   }
   SetDropMenuItem(menu_item, drop_position);
   last_drop_operation_ = drop_operation;
   return drop_operation;
 }
 
 void MenuController::OnDragExited(SubmenuView* source) {
   StartCancelAllTimer();
 
   if (drop_target_) {
     StopShowTimer();
     SetDropMenuItem(NULL, MenuDelegate::DROP_NONE);
   }
 }
 
 int MenuController::OnPerformDrop(SubmenuView* source,
                                   const DropTargetEvent& event) {
   DCHECK(drop_target_);
   // NOTE: the delegate may delete us after invoking OnPerformDrop, as such
   // we don't call cancel here.
 
   MenuItemView* item = state_.item;
   DCHECK(item);
 
   MenuItemView* drop_target = drop_target_;
   MenuDelegate::DropPosition drop_position = drop_position_;
 
   // Close all menus, including any nested menus.
-  SetSelection(NULL, false, true);
+  SetSelection(NULL, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
   CloseAllNestedMenus();
 
   // Set state such that we exit.
   showing_ = false;
   exit_type_ = EXIT_ALL;
 
   if (!IsBlockingRun())
     item->GetRootMenuItem()->DropMenuClosed(false);
 
   // WARNING: the call to MenuClosed deletes us.
@@ skipping 18 matching lines @@
 
   StopCancelAllTimer();
 }
 
 void MenuController::OnDragExitedScrollButton(SubmenuView* source) {
   StartCancelAllTimer();
   SetDropMenuItem(NULL, MenuDelegate::DROP_NONE);
   StopScrolling();
 }
 
+void MenuController::SetSelection(MenuItemView* menu_item,
+                                  int selection_types) {
+  size_t paths_differ_at = 0;
+  std::vector<MenuItemView*> current_path;
+  std::vector<MenuItemView*> new_path;
+  BuildPathsAndCalculateDiff(pending_state_.item, menu_item, &current_path,
+                             &new_path, &paths_differ_at);
+
+  size_t current_size = current_path.size();
+  size_t new_size = new_path.size();
+
+  if (pending_state_.item != menu_item && pending_state_.item) {
+    View* current_hot_view = GetFirstHotTrackedView(pending_state_.item);
+    if (current_hot_view)
+      current_hot_view->SetHotTracked(false);
+  }
+
+  // Notify the old path it isn't selected.
+  for (size_t i = paths_differ_at; i < current_size; ++i)
+    current_path[i]->SetSelected(false);
+
+  // Notify the new path it is selected.
+  for (size_t i = paths_differ_at; i < new_size; ++i)
+    new_path[i]->SetSelected(true);
+
+  if (menu_item && menu_item->GetDelegate())
+    menu_item->GetDelegate()->SelectionChanged(menu_item);
+
+  CHECK(menu_item || (selection_types & SELECTION_EXIT) != 0);
+
+  pending_state_.item = menu_item;
+  pending_state_.submenu_open = (selection_types & SELECTION_OPEN_SUBMENU) != 0;
+
+  // Stop timers.
+  StopShowTimer();
+  StopCancelAllTimer();
+
+  if (selection_types & SELECTION_UPDATE_IMMEDIATELY)
+    CommitPendingSelection();
+  else
+    StartShowTimer();
+
+  // Notify an accessibility focus event on all menu items except for the root.
+  if (menu_item &&
+      (MenuDepth(menu_item) != 1 ||
+          menu_item->GetType() != MenuItemView::SUBMENU))
+    menu_item->NotifyAccessibilityEvent(AccessibilityTypes::EVENT_FOCUS);
+}
+
 // static
 void MenuController::SetActiveInstance(MenuController* controller) {
   active_instance_ = controller;
 }
 
 #if defined(OS_WIN)
 bool MenuController::Dispatch(const MSG& msg) {
   DCHECK(blocking_run_);
 
   if (exit_type_ == EXIT_ALL || exit_type_ == EXIT_DESTROYED) {
@@ skipping 288 matching lines @@
   gfx::Point screen_menu_loc;
   View::ConvertPointToScreen(button, &screen_menu_loc);
   // Subtract 1 from the height to make the popup flush with the button border.
   UpdateInitialLocation(gfx::Rect(screen_menu_loc.x(), screen_menu_loc.y(),
                                   button->width(), button->height() - 1),
                         anchor);
   alt_menu->PrepareForRun(
       has_mnemonics,
       source->GetMenuItem()->GetRootMenuItem()->show_mnemonics_);
   alt_menu->controller_ = this;
-  SetSelection(alt_menu, true, true);
+  SetSelection(alt_menu, SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
   return true;
 }
 
 void MenuController::CloseAllNestedMenus() {
   for (std::list<State>::iterator i = menu_stack_.begin();
        i != menu_stack_.end(); ++i) {
     MenuItemView* item = i->item;
     MenuItemView* last_item = item;
     while (item) {
       CloseMenu(item);
@@ skipping 226 matching lines @@
 void MenuController::MenuChildrenChanged(MenuItemView* item) {
   DCHECK(item);
   DCHECK(item->GetSubmenu()->IsShowing());
 
   // Currently this only supports adjusting the bounds of the last menu.
   DCHECK(item == state_.item->GetParentMenuItem());
 
   // Make sure the submenu isn't showing for the current item (the position may
   // have changed or the menu removed). This also moves the selection back to
   // the parent, which handles the case where the selected item was removed.
-  SetSelection(state_.item->GetParentMenuItem(), true, true);
+  SetSelection(state_.item->GetParentMenuItem(),
+               SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
 
   OpenMenuImpl(item, false);
 }
 
 void MenuController::BuildPathsAndCalculateDiff(
     MenuItemView* old_item,
     MenuItemView* new_item,
     std::vector<MenuItemView*>* old_path,
     std::vector<MenuItemView*>* new_path,
     size_t* first_diff_at) {
@@ skipping 144 matching lines @@
 }
 
 void MenuController::IncrementSelection(int delta) {
   MenuItemView* item = pending_state_.item;
   DCHECK(item);
   if (pending_state_.submenu_open && item->HasSubmenu() &&
       item->GetSubmenu()->IsShowing()) {
     // A menu is selected and open, but none of its children are selected,
     // select the first menu item.
     if (item->GetSubmenu()->GetMenuItemCount()) {
-      SetSelection(item->GetSubmenu()->GetMenuItemAt(0), false, false);
+      SetSelection(item->GetSubmenu()->GetMenuItemAt(0), SELECTION_DEFAULT);
       ScrollToVisible(item->GetSubmenu()->GetMenuItemAt(0));
       return;
     }
   }
 
   if (item->GetChildViewCount()) {
     View* hot_view = GetFirstHotTrackedView(item);
     if (hot_view) {
       hot_view->SetHotTracked(false);
       View* to_make_hot = GetNextFocusableView(item, hot_view, delta == 1);
@@ skipping 14 matching lines @@
     MenuItemView* parent = item->GetParentMenuItem();
     int parent_count = parent->GetSubmenu()->GetMenuItemCount();
     if (parent_count > 1) {
       for (int i = 0; i < parent_count; ++i) {
         if (parent->GetSubmenu()->GetMenuItemAt(i) == item) {
           MenuItemView* to_select =
               FindNextSelectableMenuItem(parent, i, delta);
           if (!to_select)
             break;
           ScrollToVisible(to_select);
-          SetSelection(to_select, false, false);
+          SetSelection(to_select, SELECTION_DEFAULT);
           View* to_make_hot = GetInitialFocusableView(to_select, delta == 1);
           if (to_make_hot)
             to_make_hot->SetHotTracked(true);
           break;
         }
       }
     }
   }
 }
 
@@ skipping 12 matching lines @@
     if (child->IsVisible())
       return child;
   } while (index != start_index);
   return NULL;
 }
 
 void MenuController::OpenSubmenuChangeSelectionIfCan() {
   MenuItemView* item = pending_state_.item;
   if (item->HasSubmenu()) {
     if (item->GetSubmenu()->GetMenuItemCount() > 0) {
-      SetSelection(item->GetSubmenu()->GetMenuItemAt(0), false, true);
+      SetSelection(item->GetSubmenu()->GetMenuItemAt(0),
+                   SELECTION_UPDATE_IMMEDIATELY);
     } else {
       // No menu items, just show the sub-menu.
-      SetSelection(item, true, true);
+      SetSelection(item, SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
     }
   }
 }
 
 void MenuController::CloseSubmenu() {
   MenuItemView* item = state_.item;
   DCHECK(item);
   if (!item->GetParentMenuItem())
     return;
   if (item->HasSubmenu() && item->GetSubmenu()->IsShowing()) {
-    SetSelection(item, false, true);
+    SetSelection(item, SELECTION_UPDATE_IMMEDIATELY);
   } else if (item->GetParentMenuItem()->GetParentMenuItem()) {
-    SetSelection(item->GetParentMenuItem(), false, true);
+    SetSelection(item->GetParentMenuItem(), SELECTION_UPDATE_IMMEDIATELY);
   }
 }
 
 MenuController::SelectByCharDetails MenuController::FindChildForMnemonic(
     MenuItemView* parent,
     wchar_t key,
     bool (*match_function)(MenuItemView* menu, wchar_t mnemonic)) {
   SubmenuView* submenu = parent->GetSubmenu();
   DCHECK(submenu);
   SelectByCharDetails details;
@@ skipping 21 matching lines @@
 bool MenuController::AcceptOrSelect(MenuItemView* parent,
                                     const SelectByCharDetails& details) {
   // This should only be invoked if there is a match.
   DCHECK(details.first_match != -1);
   DCHECK(parent->HasSubmenu());
   SubmenuView* submenu = parent->GetSubmenu();
   DCHECK(submenu);
   if (!details.has_multiple) {
     // There's only one match, activate it (or open if it has a submenu).
     if (submenu->GetMenuItemAt(details.first_match)->HasSubmenu()) {
-      SetSelection(submenu->GetMenuItemAt(details.first_match), true, false);
+      SetSelection(submenu->GetMenuItemAt(details.first_match),
+                   SELECTION_OPEN_SUBMENU);
     } else {
       Accept(submenu->GetMenuItemAt(details.first_match), 0);
       return true;
     }
   } else if (details.index_of_item == -1 || details.next_match == -1) {
-    SetSelection(submenu->GetMenuItemAt(details.first_match), false, false);
+    SetSelection(submenu->GetMenuItemAt(details.first_match),
+                 SELECTION_DEFAULT);
   } else {
-    SetSelection(submenu->GetMenuItemAt(details.next_match), false, false);
+    SetSelection(submenu->GetMenuItemAt(details.next_match),
+                 SELECTION_DEFAULT);
   }
   return false;
 }
 
 bool MenuController::SelectByChar(wchar_t character) {
   wchar_t char_array[1] = { character };
   wchar_t key = UTF16ToWide(l10n_util::ToLower(WideToUTF16(char_array)))[0];
   MenuItemView* item = pending_state_.item;
   if (!item->HasSubmenu() || !item->GetSubmenu()->IsShowing())
     item = item->GetParentMenuItem();
@@ skipping 18 matching lines @@
   details = FindChildForMnemonic(item, key, &TitleMatchesMnemonic);
   if (details.first_match != -1)
     return AcceptOrSelect(item, details);
 
   return false;
 }
 
 #if defined(OS_WIN)
 void MenuController::RepostEvent(SubmenuView* source,
                                  const MouseEvent& event) {
+  if (!state_.item) {
+    // We some times get an event after closing all the menus. Ignore it.
+    // Make sure the menu is in fact not visible. If the menu is visible, then
+    // we're in a bad state where we think the menu isn't visibile but it is.
+    CHECK(!source->GetWidget()->IsVisible());
+    return;
+  }
+
   gfx::Point screen_loc(event.location());
   View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
   HWND window = WindowFromPoint(screen_loc.ToPOINT());
   if (window) {
     // Release the capture.
     SubmenuView* submenu = state_.item->GetRootMenuItem()->GetSubmenu();
     submenu->ReleaseCapture();
 
     if (submenu->native_window() && submenu->native_window() &&
         GetWindowThreadProcessId(submenu->native_window(), NULL) !=
@@ skipping 151 matching lines @@
 
   MouseEvent release_event(Event::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.
   View* active_view = active_mouse_view_;
   active_mouse_view_ = NULL;
   active_view->OnMouseReleased(release_event, true);
 }
 
 }  // namespace views