Keep reference view pressed while extension actions have a popup

ui/views/controls/button/menu_button.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_BUTTON_MENU_BUTTON_H_
 #define UI_VIEWS_CONTROLS_BUTTON_MENU_BUTTON_H_
 
 #include <string>
 
 #include "base/strings/string16.h"
@@ skipping 29 matching lines @@
 
   bool show_menu_marker() const { return show_menu_marker_; }
   void set_menu_marker(const gfx::ImageSkia* menu_marker) {
     menu_marker_ = menu_marker;
   }
   const gfx::ImageSkia* menu_marker() const { return menu_marker_; }
 
   const gfx::Point& menu_offset() const { return menu_offset_; }
   void set_menu_offset(int x, int y) { menu_offset_.SetPoint(x, y); }
 
+  bool menu_visible() const { return menus_visible_ > 0; }
+
+  // Increases the |menus_visible_| count by one and sets the state to be

[sky, 2014/09/18 20:02:24]

This is very fragile and not something I want in the views side. Can you isolate
this in the one place that needs it, the extensions code?

[Devlin, 2014/09/18 20:53:51]

The problem with isolating all the logic in the extensions code is that it needs
to affect three different buttons - the extension action buttons themselves, and
the two overflow buttons (either the chevron or the wrench menu).  There are a
few ways we could put more of the logic there, though:
- Make a less-fragile interface on CustomButton like ForceState(), and then have
all the logic for that contained in BrowserActionView. (This was actually my
first approach, but I realized we were trying to do this already with
menu_visible_, so went that way instead).
- Make all of these buttons inherit from a FooMenuButton class that allows for
something like this.
- Introduce a delegate of some kind that is consulted before state is actually
set, and register the extension action with the popup as the delegate.

Any of those sound reasonable?  Or is there a cleaner solution?

+  // pressed.
+  // This is public because some menus may "attach" themselves to a menu button,
+  // even if they aren't the main menu for that button (the one run via
+  // Activate()).
+  void AttachMenu();
+
+  // Decreases the |menus_visible_| count by one and sets the state to be
+  // normal if this was the last visible menu.
+  void DetachMenu();
+
   // Activate the button (called when the button is pressed).
   virtual bool Activate();
 
   // Overridden from View:
   virtual gfx::Size GetPreferredSize() const OVERRIDE;
   virtual const char* GetClassName() const OVERRIDE;
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
   virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
-  virtual void OnMouseExited(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
   virtual bool OnKeyReleased(const ui::KeyEvent& event) OVERRIDE;
   virtual void GetAccessibleState(ui::AXViewState* state) OVERRIDE;
 
  protected:
+  // MenuButton:
+  virtual bool ShouldRespondToMouseMovement() OVERRIDE;
+
   // Paint the menu marker image.
   void PaintMenuMarker(gfx::Canvas* canvas);
 
   // Overridden from LabelButton:
   virtual gfx::Rect GetChildAreaBounds() OVERRIDE;
 
   // True if the menu is currently visible.
-  bool menu_visible_;
+  int menus_visible_;
 
   // Offset of the associated menu position.
   gfx::Point menu_offset_;
 
  private:
   // Compute the maximum X coordinate for the current screen. MenuButtons
   // use this to make sure a menu is never shown off screen.
   int GetMaximumScreenXCoordinate();
 
   // We use a time object in order to keep track of when the menu was closed.
@@ skipping 16 matching lines @@
   // If non-null the destuctor sets this to true. This is set while the menu is
   // showing and used to detect if the menu was deleted while running.
   bool* destroyed_flag_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuButton);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_BUTTON_MENU_BUTTON_H_