[Media Router Action] Hide action back in the overflow menu after popping it out

chrome/browser/ui/cocoa/extensions/browser_action_button_interactive_uitest.mm

 // Copyright 2015 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.
 
 #import "chrome/browser/ui/cocoa/extensions/browser_action_button.h"
 
 #import <Cocoa/Cocoa.h>
 
 #include <memory>
 
@@ skipping 11 matching lines @@
 #include "chrome/browser/ui/browser_window.h"
 #import "chrome/browser/ui/cocoa/app_menu/app_menu_controller.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #import "chrome/browser/ui/cocoa/extensions/browser_actions_container_view.h"
 #import "chrome/browser/ui/cocoa/extensions/browser_actions_controller.h"
 #import "chrome/browser/ui/cocoa/test/run_loop_testing.h"
 #import "chrome/browser/ui/cocoa/toolbar/toolbar_controller.h"
 #include "chrome/browser/ui/global_error/global_error.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
+#include "chrome/browser/ui/toolbar/component_toolbar_actions_factory.h"
+#include "chrome/browser/ui/toolbar/media_router_action.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_model.h"
 #include "chrome/test/base/interactive_test_utils.h"
 #include "extensions/common/feature_switch.h"
 #include "ui/base/cocoa/cocoa_base_utils.h"
 #import "ui/events/test/cocoa_test_event_utils.h"
 
 namespace {
 
 const int kMenuPadding = 26;
@@ skipping 43 matching lines @@
 
 // Moves the mouse (synchronously) to the center of the given |view|.
 void MoveMouseToCenter(NSView* view) {
   NSPoint centerPoint = GetCenterPoint(view);
   base::RunLoop runLoop;
   ui_controls::SendMouseMoveNotifyWhenDone(
       centerPoint.x, centerPoint.y, runLoop.QuitClosure());
   runLoop.Run();
 }
 
+// Simulates a click on the action button in the overflow menu, and runs
+// |closure| upon completion.
+void ClickOnOverflowedAction(ToolbarController* toolbarController,
+                             const base::Closure& closure) {
+  AppMenuController* appMenuController = [toolbarController appMenuController];
+  // The app menu should start as open (since that's where the overflowed
+  // actions are).
+  EXPECT_TRUE([appMenuController isMenuOpen]);
+  BrowserActionsController* overflowController =
+      [appMenuController browserActionsController];
+
+  ASSERT_TRUE(overflowController);
+  BrowserActionButton* actionButton = [overflowController buttonWithIndex:0];
+  // The action should be attached to a superview.
+  EXPECT_TRUE([actionButton superview]);
+
+  // ui_controls:: methods don't play nice when there is an open menu (like the
+  // app menu). Instead, simulate a right click by feeding the event directly to
+  // the button.
+  NSPoint centerPoint = GetCenterPoint(actionButton);
+  NSEvent* mouseEvent = cocoa_test_event_utils::RightMouseDownAtPointInWindow(
+      centerPoint, [actionButton window]);
+  [actionButton rightMouseDown:mouseEvent];
+
+  // This should close the app menu.
+  EXPECT_FALSE([appMenuController isMenuOpen]);
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
+}
+
 }  // namespace
 
 // A simple helper menu delegate that will keep track of if a menu is opened,
 // and closes them immediately (which is useful because message loops with
 // menus open in Cocoa don't play nicely with testing).
 @interface MenuHelper : NSObject<NSMenuDelegate> {
   // Whether or not a menu has been opened. This can be reset so the helper can
   // be used multiple times.
   BOOL menuOpened_;
 
@@ skipping 117 matching lines @@
         extensions::FeatureSwitch::extension_action_redesign(), true));
     ToolbarActionsBar::disable_animations_for_testing_ = true;
   }
 
   void TearDownOnMainThread() override {
     enable_redesign_.reset();
     ToolbarActionsBar::disable_animations_for_testing_ = false;
     ExtensionBrowserTest::TearDownOnMainThread();
   }
 
+  // Opens the app menu and the context menu of the overflowed action, and
+  // checks that the menus get opened/closed properly. |menuHelper| must be set
+  // as the delegate for the context menu.
+  void OpenAppMenuAndActionContextMenu(MenuHelper* menuHelper) {
+    // Move the mouse over the app menu button.
+    MoveMouseToCenter(appMenuButton());
+
+    // No menu yet (on the browser action).
+    EXPECT_FALSE([menuHelper menuOpened]);
+    base::RunLoop runLoop;
+    // Click on the app menu, and pass in a callback to continue the test in
+    // ClickOnOverflowedAction. Due to the blocking nature of Cocoa menus, we
+    // can't test the menu synchronously here by quitting the run loop when it
+    // opens, and instead need to test through a callback.
+    base::scoped_nsobject<MenuWatcher> menuWatcher(
+        [[MenuWatcher alloc] initWithController:appMenuController()]);
+    [menuWatcher
+        setOpenClosure:base::Bind(&ClickOnOverflowedAction,
+                                  base::Unretained(toolbarController()),
+                                  runLoop.QuitClosure())];
+    ui_controls::SendMouseEvents(ui_controls::LEFT,
+                                 ui_controls::DOWN | ui_controls::UP);
+    runLoop.Run();
+
+    // The menu opened on the main bar's action button rather than the
+    // overflow's since Cocoa does not support running a menu within a menu.
+    EXPECT_TRUE([menuHelper menuOpened]);
+  }
+
   ToolbarController* toolbarController() { return toolbarController_; }
   AppMenuController* appMenuController() { return appMenuController_; }
   ToolbarActionsModel* model() { return model_; }
   NSView* appMenuButton() { return [toolbarController_ appMenuButton]; }
 
  private:
   std::unique_ptr<extensions::FeatureSwitch::ScopedOverride> enable_redesign_;
 
   ToolbarController* toolbarController_ = nil;
   AppMenuController* appMenuController_ = nil;
   ToolbarActionsModel* model_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserActionButtonUiTest);
 };
 
-// Simulates a clicks on the action button in the overflow menu, and runs
-// |closure| upon completion.
-void ClickOnOverflowedAction(ToolbarController* toolbarController,
-                             const base::Closure& closure) {
-  AppMenuController* appMenuController =
-      [toolbarController appMenuController];
-  // The app menu should start as open (since that's where the overflowed
-  // actions are).
-  EXPECT_TRUE([appMenuController isMenuOpen]);
-  BrowserActionsController* overflowController =
-      [appMenuController browserActionsController];
-
-  ASSERT_TRUE(overflowController);
-  BrowserActionButton* actionButton =
-      [overflowController buttonWithIndex:0];
-  // The action should be attached to a superview.
-  EXPECT_TRUE([actionButton superview]);
-
-  // ui_controls:: methods don't play nice when there is an open menu (like the
-  // app menu). Instead, simulate a right click by feeding the event directly to
-  // the button.
-  NSPoint centerPoint = GetCenterPoint(actionButton);
-  NSEvent* mouseEvent = cocoa_test_event_utils::RightMouseDownAtPointInWindow(
-      centerPoint, [actionButton window]);
-  [actionButton rightMouseDown:mouseEvent];
-
-  // This should close the app menu.
-  EXPECT_FALSE([appMenuController isMenuOpen]);
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
-}
-
 // Verifies that the action is "popped out" of overflow; that is, it is visible
 // on the main bar, and is set as the popped out action on the controlling
 // ToolbarActionsBar.
 void CheckActionIsPoppedOut(BrowserActionsController* actionsController,
                             BrowserActionButton* actionButton) {
   EXPECT_EQ([actionsController containerView], [actionButton superview]);
   EXPECT_EQ([actionButton viewController],
             [actionsController toolbarActionsBar]->popped_out_action());
   // Since the button is popped out for a popup or context menu, it should be
   // highlighted.
@@ skipping 47 matching lines @@
 
   // Reset the menu helper so we can use it again.
   [menuHelper setMenuOpened:NO];
   [menuHelper setVerify:base::Bind(
       CheckActionIsPoppedOut, actionsController, actionButton)];
 
   // Shrink the visible count to be 0. This should hide the action button.
   model()->SetVisibleIconCount(0);
   EXPECT_EQ(nil, [actionButton superview]);
 
-  // Move the mouse over the app menu button.
-  MoveMouseToCenter(appMenuButton());
+  OpenAppMenuAndActionContextMenu(menuHelper.get());
+}
 
-  {
-    // No menu yet (on the browser action).
-    EXPECT_FALSE([menuHelper menuOpened]);
-    base::RunLoop runLoop;
-    // Click on the app menu, and pass in a callback to continue the test in
-    // ClickOnOverflowedAction (Due to the blocking nature of Cocoa menus,
-    // passing in runLoop.QuitClosure() is not sufficient here.)
-    base::scoped_nsobject<MenuWatcher> menuWatcher(
-        [[MenuWatcher alloc] initWithController:appMenuController()]);
-    [menuWatcher setOpenClosure:
-        base::Bind(&ClickOnOverflowedAction,
-                   base::Unretained(toolbarController()),
-                   runLoop.QuitClosure())];
-    ui_controls::SendMouseEvents(ui_controls::LEFT,
-                                 ui_controls::DOWN | ui_controls::UP);
-    runLoop.Run();
+IN_PROC_BROWSER_TEST_F(BrowserActionButtonUiTest,
+                       MediaRouterActionContextMenuInOverflow) {
+  model()->AddComponentAction(
+      ComponentToolbarActionsFactory::kMediaRouterActionId);
+  ASSERT_EQ(1u, model()->toolbar_items().size());
 
-    // The menu should have opened. Note that the menu opened on the main bar's
-    // action button, not the overflow's. Since Cocoa doesn't support running
-    // a menu-within-a-menu, this is what has to happen.
-    EXPECT_TRUE([menuHelper menuOpened]);
-    EXPECT_FALSE([actionButton isHighlighted]);
-  }
+  BrowserActionButton* actionButton =
+      [[toolbarController() browserActionsController] buttonWithIndex:0];
+  ASSERT_TRUE(actionButton);
+
+  // Stub out the action button's normal context menu with a fake one so we
+  // can track when it opens.
+  base::scoped_nsobject<NSMenu> testContextMenu(
+      [[NSMenu alloc] initWithTitle:@""]);
+  base::scoped_nsobject<MenuHelper> menuHelper([[MenuHelper alloc] init]);
+  [testContextMenu setDelegate:menuHelper.get()];
+  [actionButton setTestContextMenu:testContextMenu.get()];
+
+  model()->SetActionVisibility(
+      ComponentToolbarActionsFactory::kMediaRouterActionId, false);
+
+  OpenAppMenuAndActionContextMenu(menuHelper.get());
+
+  ToolbarActionsBar* actions_bar =

[Robert Sesek, 2017/01/03 21:42:22]

nit: while under_scores are correct for this function, the variables above are
camelCase, and this file is generally camelCase (even though the correct style
is under_scores), so let's be consistent here.

[takumif, 2017/01/03 22:09:37]

Done.

+      [[toolbarController() browserActionsController] toolbarActionsBar];
+  // The action should be back in the overflow.
+  EXPECT_FALSE(
+      actions_bar->IsActionVisibleOnMainBar(actions_bar->GetActions()[0]));
 }
 
 // Checks the layout of the overflow bar in the app menu.
 void CheckAppMenuLayout(ToolbarController* toolbarController,
                         int overflowStartIndex,
                         const std::string& error_message,
                         const base::Closure& closure) {
   AppMenuController* appMenuController =
       [toolbarController appMenuController];
   // The app menu should start as open (since that's where the overflowed
@@ skipping 262 matching lines @@
   openAndCloseAppMenu(appMenuController());
 
   // Move the extension back to the main bar, so an overflow bar is no longer
   // needed. Then open and close the app menu a couple times.
   // This tests that the menu properly cleans up after itself when an overflow
   // was present, and is no longer (fix for crbug.com/603241).
   model()->SetVisibleIconCount(1);
   openAndCloseAppMenu(appMenuController());
   openAndCloseAppMenu(appMenuController());
 }