Change MenuControllerDelegate to provide WeakPtr

ui/views/controls/menu/menu_controller.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 "ui/views/controls/menu/menu_controller.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 504 matching lines @@
   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;
-    delegate_->OnMenuClosed(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
-                            selected->GetRootMenuItem(), accept_event_flags_);
+    // Verify that the delegate was not destroyed.
+    if (delegate_) {
+      delegate_->OnMenuClosed(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
+                              selected->GetRootMenuItem(), accept_event_flags_);
+    }
     // WARNING: the call to MenuClosed deletes us.
     return;
   }
 
   // On Windows and Linux the destruction of this menu's Widget leads to the
   // teardown of the platform specific drag-and-drop Widget. Do not shutdown
   // while dragging, leave the Widget hidden until drag-and-drop has completed,
   // at which point all menus will be destroyed.
   //
   // If |type| is EXIT_ALL we update the state of the menu to not showing. So
   // that during the completion of a drag we are not incorrectly reporting the
   // visual state.
   if (!drag_in_progress_)
     ExitAsyncRun();
   else if (type == EXIT_ALL)
     showing_ = false;
 }
 
 void MenuController::AddNestedDelegate(
     internal::MenuControllerDelegate* delegate) {
-  delegate_stack_.push_back(std::make_pair(delegate, async_run_));
-  delegate_ = delegate;
+  delegate_stack_.push_back(std::make_pair(delegate->AsWeakPtr(), async_run_));
+  delegate_ = delegate->AsWeakPtr();
 }
 
 void MenuController::SetAsyncRun(bool is_async) {
   delegate_stack_.back().second = is_async;
   async_run_ = is_async;
 }
 
 bool MenuController::OnMousePressed(SubmenuView* source,
                                     const ui::MouseEvent& event) {
   // We should either have no current_mouse_event_target_, or should have a
@@ skipping 412 matching lines @@
   CloseAllNestedMenus();
 
   // Set state such that we exit.
   showing_ = false;
   SetExitType(EXIT_ALL);
 
   // If over an empty menu item, drop occurs on the parent.
   if (drop_target->id() == MenuItemView::kEmptyMenuItemViewID)
     drop_target = drop_target->GetParentMenuItem();
 
-  if (!IsBlockingRun()) {
+  if (!IsBlockingRun() && delegate_) {
     delegate_->OnMenuClosed(
         internal::MenuControllerDelegate::DONT_NOTIFY_DELEGATE,
         item->GetRootMenuItem(), accept_event_flags_);
   }
 
   // WARNING: the call to MenuClosed deletes us.
 
   return drop_target->GetDelegate()->OnPerformDrop(
       drop_target, drop_position, event);
 }
@@ skipping 396 matching lines @@
       drop_position_(MenuDelegate::DROP_UNKNOWN),
       owner_(NULL),
       possible_drag_(false),
       drag_in_progress_(false),
       did_initiate_drag_(false),
       valid_drop_coordinates_(false),
       last_drop_operation_(MenuDelegate::DROP_UNKNOWN),
       showing_submenu_(false),
       active_mouse_view_id_(ViewStorage::GetInstance()->CreateStorageID()),
       hot_button_(nullptr),
-      delegate_(delegate),
+      delegate_(delegate->AsWeakPtr()),
       message_loop_depth_(0),
       async_run_(false),
       is_combobox_(false),
       item_selected_by_touch_(false),
       current_mouse_event_target_(nullptr),
       current_mouse_pressed_state_(0),
       message_loop_(MenuMessageLoop::Create()) {
   delegate_stack_.push_back(std::make_pair(delegate_, async_run_));
   active_instance_ = this;
 }
@@ skipping 106 matching lines @@
   View::ConvertPointToScreen(source_view, &screen_point);
   MenuAnchorPosition anchor;
   bool has_mnemonics;
   MenuButton* button = NULL;
   MenuItemView* alt_menu = source->GetMenuItem()->GetDelegate()->
       GetSiblingMenu(source->GetMenuItem()->GetRootMenuItem(),
                      screen_point, &anchor, &has_mnemonics, &button);
   if (!alt_menu || (state_.item && state_.item->GetRootMenuItem() == alt_menu))
     return false;
 
-  delegate_->SiblingMenuCreated(alt_menu);
+  if (delegate_)
+    delegate_->SiblingMenuCreated(alt_menu);
 
   if (!button) {
     // If the delegate returns a menu, they must also return a button.
     NOTREACHED();
     return false;
   }
 
   // There is a sibling menu, update the button state, hide the current menu
   // and show the new one.
   pressed_lock_.reset(
@@ skipping 1042 matching lines @@
   if (quit_now)
     message_loop_->QuitNow();
   return quit_now;
 }
 
 void MenuController::ExitAsyncRun() {
   if (!async_run_)
     return;
   bool nested = delegate_stack_.size() > 1;
   // ExitMenuRun unwinds nested delegates
-  internal::MenuControllerDelegate* delegate = delegate_;
+  base::WeakPtr<internal::MenuControllerDelegate> delegate = delegate_;
   // MenuController may have been deleted when releasing ViewsDelegate ref.
   // However as |delegate| can outlive this, it must still be notified of the
   // menu closing so that it can perform teardown.
   int accept_event_flags = accept_event_flags_;
   base::WeakPtr<MenuController> this_ref = AsWeakPtr();
   MenuItemView* result = ExitMenuRun();
-  delegate->OnMenuClosed(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
-                         result, accept_event_flags);
+  // The delegate may have been deleted.
+  if (delegate) {
+    delegate->OnMenuClosed(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
+                           result, accept_event_flags);
+  }
   // |delegate| may have deleted this.
   if (this_ref && nested && exit_type_ == EXIT_ALL)
     ExitAsyncRun();
 }
 
 MenuItemView* MenuController::ExitMenuRun() {
   base::WeakPtr<MenuController> this_ref = AsWeakPtr();
 
   // Release the lock which prevents Chrome from shutting down while the menu is
   // showing.
@@ skipping 139 matching lines @@
   if (hot_button_)
     hot_button_->SetHotTracked(false);
   hot_button_ = hot_button;
   if (hot_button) {
     hot_button->SetHotTracked(true);
     hot_button->NotifyAccessibilityEvent(ui::AX_EVENT_SELECTION, true);
   }
 }
 
 }  // namespace views