Make shelf item can be dragged when context menu is opened.

ui/views/controls/menu/menu_controller.h

 // 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.
 
 #ifndef UI_VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_
 #define UI_VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_
 
 #include <stddef.h>
 
 #include <list>
@@ skipping 85 matching lines @@
 
   bool in_nested_run() const { return !menu_stack_.empty(); }
 
   // Whether or not drag operation is in progress.
   bool drag_in_progress() const { return drag_in_progress_; }
 
   // Whether the MenuController initiated the drag in progress. False if there
   // is no drag in progress.
   bool did_initiate_drag() const { return did_initiate_drag_; }
 
+  bool send_gesture_events_to_owner() const {
+    return send_gesture_events_to_owner_;
+  }
+
+  void set_send_gesture_events_to_owner(bool send_gesture_events_to_owner) {
+    send_gesture_events_to_owner_ = send_gesture_events_to_owner;
+  }
+
   // Returns the owner of child windows.
   // WARNING: this may be NULL.
   Widget* owner() { return owner_; }
 
   // Get the anchor position wich is used to show this menu.
   MenuAnchorPosition GetAnchorPosition() { return state_.anchor; }
 
   // Cancels the current Run. See ExitType for a description of what happens
   // with the various parameters.
   void Cancel(ExitType type);
@@ skipping 434 matching lines @@
   // The active instance.
   static MenuController* active_instance_;
 
   // If true, Run blocks. If false, Run doesn't block and this is used for
   // drag and drop. Note that the semantics for drag and drop are slightly
   // different: cancel timer is kicked off any time the drag moves outside the
   // menu, mouse events do nothing...
   bool blocking_run_;
 
   // If true, we're showing.
-  bool showing_;
+  bool showing_ = false;
 
   // Indicates what to exit.
-  ExitType exit_type_;
+  ExitType exit_type_ = EXIT_NONE;
 
   // Whether we did a capture. We do a capture only if we're blocking and
   // the mouse was down when Run.
-  bool did_capture_;
+  bool did_capture_ = false;
 
   // As the user drags the mouse around pending_state_ changes immediately.
   // When the user stops moving/dragging the mouse (or clicks the mouse)
   // pending_state_ is committed to state_, potentially resulting in
   // opening or closing submenus. This gives a slight delayed effect to
   // submenus as the user moves the mouse around. This is done so that as the
   // user moves the mouse all submenus don't immediately pop.
   State pending_state_;
   State state_;
 
   // If the user accepted the selection, this is the result.
-  MenuItemView* result_;
+  MenuItemView* result_ = nullptr;
 
   // The event flags when the user selected the menu.
-  int accept_event_flags_;
+  int accept_event_flags_ = 0;
 
   // If not empty, it means we're nested. When Run is invoked from within
   // Run, the current state (state_) is pushed onto menu_stack_. This allows
   // MenuController to restore the state when the nested run returns.
   using NestedState =
       std::pair<State, std::unique_ptr<MenuButton::PressedLock>>;
   std::list<NestedState> menu_stack_;
 
   // When Run is invoked during an active Run, it may be called from a separate
   // MenuControllerDelegate. If not empty it means we are nested, and the
   // stacked delegates should be notified instead of |delegate_|.
   std::list<internal::MenuControllerDelegate*> delegate_stack_;
 
   // As the mouse moves around submenus are not opened immediately. Instead
   // they open after this timer fires.
   base::OneShotTimer show_timer_;
 
   // Used to invoke CancelAll(). This is used during drag and drop to hide the
   // menu after the mouse moves out of the of the menu. This is necessitated by
   // the lack of an ability to detect when the drag has completed from the drop
   // side.
   base::OneShotTimer cancel_all_timer_;
 
   // Drop target.
-  MenuItemView* drop_target_;
-  MenuDelegate::DropPosition drop_position_;
+  MenuItemView* drop_target_ = nullptr;
+  MenuDelegate::DropPosition drop_position_ = MenuDelegate::DROP_UNKNOWN;
 
   // Owner of child windows.
   // WARNING: this may be NULL.
-  Widget* owner_;
+  Widget* owner_ = nullptr;
 
   // Indicates a possible drag operation.
-  bool possible_drag_;
+  bool possible_drag_ = false;
 
   // True when drag operation is in progress.
-  bool drag_in_progress_;
+  bool drag_in_progress_ = false;
 
   // True when the drag operation in progress was initiated by the
   // MenuController for a child MenuItemView (as opposed to initiated separately
   // by a child View).
-  bool did_initiate_drag_;
+  bool did_initiate_drag_ = false;
 
   // Location the mouse was pressed at. Used to detect d&d.
   gfx::Point press_pt_;
 
   // We get a slew of drag updated messages as the mouse is over us. To avoid
   // continually processing whether we can drop, we cache the coordinates.
-  bool valid_drop_coordinates_;
+  bool valid_drop_coordinates_ = false;
   gfx::Point drop_pt_;
-  int last_drop_operation_;
+  int last_drop_operation_ = MenuDelegate::DROP_UNKNOWN;
 
   // If true, we're in the middle of invoking ShowAt on a submenu.
-  bool showing_submenu_;
+  bool showing_submenu_ = false;
 
   // Task for scrolling the menu. If non-null indicates a scroll is currently
   // underway.
   std::unique_ptr<MenuScrollTask> scroll_task_;
 
   // The lock to keep the menu button pressed while a menu is visible.
   std::unique_ptr<MenuButton::PressedLock> pressed_lock_;
 
   // ViewTracker used to store the View mouse drag events are forwarded to. See
   // UpdateActiveMouseView() for details.
   std::unique_ptr<ViewTracker> active_mouse_view_tracker_;
 
   // Current hot tracked child button if any.
-  Button* hot_button_;
+  Button* hot_button_ = nullptr;
 
   internal::MenuControllerDelegate* delegate_;
 
   // The timestamp of the event which closed the menu - or 0 otherwise.
   base::TimeTicks closing_event_time_;
 
   // Time when the menu is first shown.
   base::TimeTicks menu_start_time_;
 
   // If a mouse press triggered this menu, this will have its location (in
   // screen coordinates). Otherwise this will be (0, 0).
   gfx::Point menu_start_mouse_press_loc_;
 
   // Controls behavior differences between a combobox and other types of menu
   // (like a context menu).
-  bool is_combobox_;
+  bool is_combobox_ = false;
+
+  // Whether the menu |owner_| needs gesture events. When set to true, the menu
+  // will help preserve the gesture events of the |owner_| and then
+  // MenuController will forward the gesture events to |owner_| if
+  // no |ET_GESTURE_END| event been captured.
+  bool send_gesture_events_to_owner_ = false;
 
   // Set to true if the menu item was selected by touch.
-  bool item_selected_by_touch_;
+  bool item_selected_by_touch_ = false;
 
   // During mouse event handling, this is the RootView to forward mouse events
   // to. We need this, because if we forward one event to it (e.g., mouse
   // pressed), subsequent events (like dragging) should also go to it, even if
   // the mouse is no longer over the view.
-  MenuHostRootView* current_mouse_event_target_;
+  MenuHostRootView* current_mouse_event_target_ = nullptr;
 
   // A mask of the EventFlags for the mouse buttons currently pressed.
-  int current_mouse_pressed_state_;
+  int current_mouse_pressed_state_ = 0;
 
 #if defined(USE_AURA)
   std::unique_ptr<MenuPreTargetHandler> menu_pre_target_handler_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(MenuController);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_